feat: add uploadthing driver

docs/content/2.drivers/uploadthing.md

@@ -0,0 +1,32 @@
+# UploadThing
+
+Store data using UploadThing.
+
+::note{to="https://uploadthing.com/"}
+Learn more about UploadThing.
+::
+
+```js
+import { createStorage } from "unstorage";
+import uploadthingDriver from "unstorage/drivers/uploadthing";
+
+const storage = createStorage({
+  driver: uploadthingDriver({
+    // apiKey: "<your api key>",
+  }),
+});
+```
+
+To use, you will need to install `uploadthing` dependency in your project:
+
+```json
+{
+  "dependencies": {
+    "uploadthing": "latest"
+  }
+}
+```
+
+**Options:**
+
+- `apiKey`: Your UploadThing API key. Will be automatically inferred from the `UPLOADTHING_SECRET` environment variable if not provided.

package.json

@@ -92,6 +92,7 @@
     "types-cloudflare-worker": "^1.2.0",
     "typescript": "^5.3.3",
     "unbuild": "^2.0.0",
+    "uploadthing": "6.3.2-canary.a35b49f",
     "vite": "^5.0.11",
     "vitest": "^1.2.1",
     "vue": "^3.4.14"
@@ -108,7 +109,8 @@
     "@planetscale/database": "^1.13.0",
     "@upstash/redis": "^1.28.1",
     "@vercel/kv": "^0.2.4",
-    "idb-keyval": "^6.2.1"
+    "idb-keyval": "^6.2.1",
+    "uploadthing": "^6.0.0"
   },
   "peerDependenciesMeta": {
     "@azure/app-configuration": {
@@ -146,6 +148,9 @@
     },
     "idb-keyval": {
       "optional": true
+    },
+    "uploadthing": {
+      "optional": true
     }
   },
   "packageManager": "pnpm@8.14.1"

src/drivers/uploadthing.ts

@@ -0,0 +1,99 @@
+import { defineDriver } from "./utils";
+import { ofetch, $Fetch } from "ofetch";
+import { UTApi } from "uploadthing/server";
+
+export interface UploadThingOptions {
+  apiKey: string;
+}
+
+export default defineDriver<UploadThingOptions>((opts) => {
+  let client: UTApi;
+  let utApiFetch: $Fetch;
+
+  const getClient = () => {
+    return (client ??= new UTApi({
+      apiKey: opts.apiKey,
+      fetch: ofetch.native,
+    }));
+  };
+
+  // The UTApi doesn't have all methods we need right now, so use raw fetch
+  const getUTApiFetch = () => {
+    return (utApiFetch ??= ofetch.create({
+      method: "POST",
+      baseURL: "https://uploadthing.com/api",
+      headers: {
+        "x-uploadthing-api-key": opts.apiKey,
+      },
+    }));
+  };
+
+  function getKeys() {
+    return getClient()
+      .listFiles({})
+      .then((res) =>
+        res.map((file) => file.customId).filter((k): k is string => !!k)
+      );
+  }
+
+  return {
+    hasItem(id) {
+      return getClient()
+        .getFileUrls(id, { keyType: "customId" })
+        .then((res) => {
+          return !!res.length;
+        });
+    },
+    async getItem(id) {
+      const url = await getClient()
+        .getFileUrls(id, { keyType: "customId" })
+        .then((res) => {
+          return res[0]?.url;
+        });
+      if (!url) return null;
+      return ofetch(url).then((res) => res.text());
+    },
+    getKeys() {
+      return getKeys();
+    },
+    setItem(key, value, opts) {
+      return getClient()
+        .uploadFiles(
+          Object.assign(new Blob([value]), {
+            name: key,
+            customId: key,
+          }),
+          { metadata: opts?.metadata }
+        )
+        .then(() => {});
+    },
+    setItems(items, opts) {
+      return getClient()
+        .uploadFiles(
+          items.map((item) =>
+            Object.assign(new Blob([item.value]), {
+              name: item.key,
+              customId: item.key,
+            })
+          ),
+          { metadata: opts?.metadata }
+        )
+        .then(() => {});
+    },
+    removeItem(key, opts) {
+      return getClient()
+        .deleteFiles([key], { keyType: "customId" })
+        .then(() => {});
+    },
+    async clear() {
+      const keys = await getKeys();
+      return getClient()
+        .deleteFiles(keys, { keyType: "customId" })
+        .then(() => {});
+    },
+
+    // getMeta(key, opts) {
+    //   // TODO: We don't currently have an endpoint to fetch metadata, but it does exist
+    // },
+  };
+});

src/storage.ts

@@ -231,7 +231,7 @@ export function createStorage<T extends StorageValue>(
     async setItems(items, commonOptions) {
       await runBatch(items, commonOptions, async (batch) => {
         if (batch.driver.setItems) {
-          await asyncCall(
+          return asyncCall(
             batch.driver.setItems,
             batch.items.map((item) => ({
               key: item.relativeKey,

test/drivers/uploadthing.test.ts

@@ -0,0 +1,80 @@
+import { afterAll, beforeAll, describe, it } from "vitest";
+import driver from "../../src/drivers/uploadthing";
+import { testDriver } from "./utils";
+import { setupServer } from "msw/node";
+import { rest } from "msw";
+
+const store: Record<string, any> = {};
+
+const utapiUrl = "https://uploadthing.com/api";
+const utfsUrl = "https://utfs.io/f";
+
+const server = setupServer(
+  rest.post(`${utapiUrl}/getFileUrl`, async (req, res, ctx) => {
+    const { fileKeys } = await req.json();
+    const key = fileKeys[0];
+    if (!(key in store)) {
+      return res(ctx.status(401), ctx.json({ error: "Unauthorized" }));
+    }
+    return res(
+      ctx.status(200),
+      ctx.json({
+        result: {
+          [key]: `https://utfs.io/f/${key}`,
+        },
+      })
+    );
+  }),
+  rest.get(`${utfsUrl}/:key`, (req, res, ctx) => {
+    const key = req.params.key as string;
+    if (!(key in store)) {
+      return res(ctx.status(404), ctx.json(null));
+    }
+    return res(
+      ctx.status(200),
+      ctx.set("content-type", "application/octet-stream"),
+      ctx.body(store[key])
+    );
+  }),
+  rest.post(`${utapiUrl}/uploadFiles`, async (req, res, ctx) => {
+    console.log("intercepted request");
+    return res(
+      ctx.status(200),
+      ctx.json({
+        data: [
+          {
+            presignedUrls: [`https://my-s3-server.com/:key`],
+          },
+        ],
+      })
+    );
+  }),
+  rest.post(`${utapiUrl}/deleteFile`, async (req, res, ctx) => {
+    console.log("hello????");
+    const { fileKeys } = await req.json();
+    for (const key of fileKeys) {
+      delete store[key];
+    }
+    return res(ctx.status(200), ctx.json({ success: true }));
+  })
+);
+
+describe(
+  "drivers: uploadthing",
+  () => {
+    //   beforeAll(() => {
+    //     server.listen();
+    //   });
+    //   afterAll(() => {
+    //     server.close();
+    //   });
+
+    testDriver({
+      driver: driver({
+        apiKey: "sk_live_xxx",
+      }),
+      async additionalTests(ctx) {},
+    });
+  },
+  { timeout: 30e3 }
+);