import { createUploadthing, type FileRouter } from "uploadthing/next";
 
const f = createUploadthing();
 
export const ourFileRouter = {
  // Example "profile picture upload" route - these can be named whatever you want!
  profilePicture: f(["image"])
    .middleware(({ req }) => auth(req))
    .onUploadComplete((data) => console.log("file", data)),
 
  // This route takes an attached image OR video
  messageAttachment: f(["image", "video"])
    .middleware(({ req }) => auth(req))
    .onUploadComplete((data) => console.log("file", data)),
 
  // Takes ONE image up to 2MB
  strictImageAttachment: f({ image: { maxFileSize: "2MB", maxFileCount: 1 } })
    .middleware(({ req }) => auth(req))
    .onUploadComplete((data) => console.log("file", data)),
 
  // Takes a 4 2mb images and/or 1 256mb video
  mediaPost: f({
    image: { maxFileSize: "2MB", maxFileCount: 4 },
    video: { maxFileSize: "256MB", maxFileCount: 1 },
  })
    .middleware(({ req }) => auth(req))
    .onUploadComplete((data) => console.log("file", data)),
} satisfies FileRouter;
 
export type OurFileRouter = typeof ourFileRouter;

// Your file types can be any of the following types
type MimeType = /** any web mime-type */
type ValidFileTypes = "image" | "video" | "audio" | "blob" | "pdf" | "text" | MimeType;
type ContentDisposition = "inline" | "attachment";
 
// The input to your f() function can be an array of file types OR an object of them w/ config
type FileRouterInput =
  | ValidFileTypes[]
  | {
      [key: ValidFileTypes]: {
        maxFileSize?: string;
        maxFileCount?: number;
        contentDisposition?: ContentDisposition = "inline";
      };
    };

import { z } from "zod";
 
f(["image"])
  .input(z.object({ foo: z.string() }))
  .middleware(async ({ req, input }) => {
    input;
    // ^? { foo: string }
    return {};
  })
  .onUploadComplete(async () => {});

import { currentUser } from "@clerk/nextjs";
 
f(["image"])
  .middleware(async ({ req, res }) => {
    const user = await currentUser();
 
    // Throw if user isn't signed in
    if (!user)
      throw new Error("You must be logged in to upload a profile picture");
 
    // Return userId to be used in onUploadComplete
    return { userId: user.id };
  })
  .onUploadComplete(async ({ metadata }) => {
    console.log("Uploaded by user", metadata.userId);
  });

import { UTApi } from "uploadthing/server";
 
export const utapi = new UTApi();

{
  fetch: FetchEsque = globalThis.fetch; // subset of standard fetch required for uploadthing
  apiKey: string = process.env.UPLOADTHING_SECRET;
}

import { utapi } from "~/server/uploadthing.ts";
 
async function uploadFiles(formData: FormData) {
  "use server";
  const files = formData.getAll("files");
  const response = await utapi.uploadFiles(files);
  //    ^? UploadedFileResponse[]
}
 
function MyForm() {
  return (
    <form action={uploadFiles}>
      <input name="files" type="file" multiple />
      <button type="submit">Upload</button>
    </form>
  );
}

// Edge / Node < 20 friendly File interface
interface FileEsque extends Blob {
  name: string;
}

type UploadFileResponse =
  | { data: UploadData; error: null }
  | { data: null; error: UploadError };
 
type UploadData = {
  key: string;
  url: string;
  name: string;
  size: number;
};
 
type UploadError = {
  code: string;
  message: string;
  data: any;
};

import { utapi } from "~/server/uploadthing.ts";
 
const fileUrl = "https://test.com/some.png";
const uploadedFile = await utapi.uploadFilesFromUrl(fileUrl);
//    ^? UploadedFileResponse
 
const fileUrls = ["https://test.com/some.png", "https://test.com/some2.png"];
const uploadedFiles = await utapi.uploadFilesFromUrl(fileUrls);
//    ^? UploadedFileResponse[]

import { utapi } from "~/server/uploadthing.ts";
 
await utapi.deleteFiles("2e0fdb64-9957-4262-8e45-f372ba903ac8_image.jpg");
await utapi.deleteFiles([
  "2e0fdb64-9957-4262-8e45-f372ba903ac8_image.jpg",
  "1649353b-04ea-48a2-9db7-31de7f562c8d_image2.jpg",
]);

import { utapi } from "~/server/uploadthing.ts";
 
const oneUrl = await utapi.getFileUrls(
  "2e0fdb64-9957-4262-8e45-f372ba903ac8_image.jpg",
);
const multipleUrls = await utapi.getFileUrls([
  "2e0fdb64-9957-4262-8e45-f372ba903ac8_image.jpg",
  "1649353b-04ea-48a2-9db7-31de7f562c8d_image2.jpg",
]);

import { utapi } from "~/server/uploadthing.ts";
 
const files = await utapi.listFiles();
 
console.log(files);
/*
 * [
 *  {
 *    id: "2e0fdb64-9957-4262-8e45-f372ba903ac8",
 *    key: "2e0fdb64-9957-4262-8e45-f372ba903ac8_image.jpg"
 *  }
 * ]
 */

import { utapi } from "~/server/uploadthing.ts";
 
await utapi.renameFiles({
  fileKey: "2e0fdb64-9957-4262-8e45-f372ba903ac8_image.jpg",
  newName: "myImage.jpg",
});
 
await utapi.renameFiles([
  {
    fileKey: "2e0fdb64-9957-4262-8e45-f372ba903ac8_image.jpg",
    newName: "myImage.jpg",
  },
  {
    fileKey: "1649353b-04ea-48a2-9db7-31de7f562c8d_image2.jpg",
    newName: "myOtherImage.jpg",
  },
]);

type Rename = {
  fileKey: string;
  newName: string; // should include file extension
};