(squash) init

feat: filters, settings, backups

fix: ts compile errors

feat: new dashboard, webp previews and settings

feat: use webp for pdfs

feat: use webp

fix: analyze resets old data

fix: switch to corsproxy

fix: switch to free cors

fix: max upload limit

fix: currency conversion

feat: transaction export

fix: currency conversion

feat: refactor settings actions

feat: new loader

feat: README + LICENSE

doc: update readme

doc: update readme

doc: update readme

doc: update screenshots

ci: bump prisma

app/files/actions.ts

@@ -0,0 +1,52 @@
+"use server"
+
+import { createFile } from "@/data/files"
+import { FILE_UNSORTED_UPLOAD_PATH, getUnsortedFileUploadPath } from "@/lib/files"
+import { existsSync } from "fs"
+import { mkdir, writeFile } from "fs/promises"
+import { revalidatePath } from "next/cache"
+
+export async function uploadFilesAction(prevState: any, formData: FormData) {
+  const files = formData.getAll("files")
+
+  // Make sure upload dir exists
+  if (!existsSync(FILE_UNSORTED_UPLOAD_PATH)) {
+    await mkdir(FILE_UNSORTED_UPLOAD_PATH, { recursive: true })
+  }
+
+  // Process each file
+  const uploadedFiles = await Promise.all(
+    files.map(async (file) => {
+      if (!(file instanceof File)) {
+        return { success: false, error: "Invalid file" }
+      }
+
+      // Save file to filesystem
+      const { fileUuid, filePath } = await getUnsortedFileUploadPath(file.name)
+      const arrayBuffer = await file.arrayBuffer()
+      const buffer = Buffer.from(arrayBuffer)
+
+      await writeFile(filePath, buffer)
+
+      // Create file record in database
+      const fileRecord = await createFile({
+        id: fileUuid,
+        filename: file.name,
+        path: filePath,
+        mimetype: file.type,
+        metadata: {
+          size: file.size,
+          lastModified: file.lastModified,
+        },
+      })
+
+      return fileRecord
+    })
+  )
+
+  console.log("uploadedFiles", uploadedFiles)
+
+  revalidatePath("/unsorted")
+
+  return { success: true, error: null }
+}

app/files/download/[fileId]/route.ts

@@ -0,0 +1,41 @@
+import { getFileById } from "@/data/files"
+import fs from "fs/promises"
+import { NextResponse } from "next/server"
+
+export async function GET(request: Request, { params }: { params: Promise<{ fileId: string }> }) {
+  const { fileId } = await params
+
+  if (!fileId) {
+    return new NextResponse("No fileId provided", { status: 400 })
+  }
+
+  try {
+    // Find file in database
+    const file = await getFileById(fileId)
+
+    if (!file) {
+      return new NextResponse("File not found", { status: 404 })
+    }
+
+    // Check if file exists
+    try {
+      await fs.access(file.path)
+    } catch {
+      return new NextResponse("File not found on disk", { status: 404 })
+    }
+
+    // Read file
+    const fileBuffer = await fs.readFile(file.path)
+
+    // Return file with proper content type
+    return new NextResponse(fileBuffer, {
+      headers: {
+        "Content-Type": file.mimetype,
+        "Content-Disposition": `attachment; filename="${file.filename}"`,
+      },
+    })
+  } catch (error) {
+    console.error("Error serving file:", error)
+    return new NextResponse("Internal Server Error", { status: 500 })
+  }
+}

app/files/page.tsx

@@ -0,0 +1,10 @@
+import { Metadata } from "next"
+import { notFound } from "next/navigation"
+
+export const metadata: Metadata = {
+  title: "Uploading...",
+}
+
+export default function UploadStatusPage() {
+  notFound()
+}

app/files/preview/[fileId]/route.ts

@@ -0,0 +1,66 @@
+import { getFileById } from "@/data/files"
+import { resizeImage } from "@/lib/images"
+import { pdfToImages } from "@/lib/pdf"
+import fs from "fs/promises"
+import { NextResponse } from "next/server"
+import path from "path"
+
+export async function GET(request: Request, { params }: { params: Promise<{ fileId: string }> }) {
+  const { fileId } = await params
+
+  if (!fileId) {
+    return new NextResponse("No fileId provided", { status: 400 })
+  }
+
+  const url = new URL(request.url)
+  const page = parseInt(url.searchParams.get("page") || "1", 10)
+
+  try {
+    // Find file in database
+    const file = await getFileById(fileId)
+
+    if (!file) {
+      return new NextResponse("File not found", { status: 404 })
+    }
+
+    // Check if file exists
+    try {
+      await fs.access(file.path)
+    } catch {
+      return new NextResponse("File not found on disk", { status: 404 })
+    }
+
+    let previewPath = file.path
+    let previewType = file.mimetype
+
+    if (file.mimetype === "application/pdf") {
+      const { contentType, pages } = await pdfToImages(file.path)
+      if (page > pages.length) {
+        return new NextResponse("Page not found", { status: 404 })
+      }
+      previewPath = pages[page - 1] || file.path
+      previewType = contentType
+    } else if (file.mimetype.startsWith("image/")) {
+      const { contentType, resizedPath } = await resizeImage(file.path)
+      previewPath = resizedPath
+      previewType = contentType
+    } else {
+      previewPath = file.path
+      previewType = file.mimetype
+    }
+
+    // Read filex
+    const fileBuffer = await fs.readFile(previewPath)
+
+    // Return file with proper content type
+    return new NextResponse(fileBuffer, {
+      headers: {
+        "Content-Type": previewType,
+        "Content-Disposition": `inline; filename="${path.basename(previewPath)}"`,
+      },
+    })
+  } catch (error) {
+    console.error("Error serving file:", error)
+    return new NextResponse("Internal Server Error", { status: 500 })
+  }
+}