feat: add uploadthing driver

package.json

@@ -92,6 +92,7 @@
     "types-cloudflare-worker": "^1.2.0",
     "typescript": "^5.3.3",
     "unbuild": "^2.0.0",
+    "uploadthing": "^6.3.0",
     "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": "[email protected]"

src/drivers/uploadthing.ts

@@ -0,0 +1,116 @@
+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;
+  let utFsFetch: $Fetch;
+
+  const internalToUTKeyMap = new Map<string, string>();
+  const fromUTKey = (utKey: string) => {
+    for (const [key, value] of internalToUTKeyMap.entries()) {
+      if (value === utKey) {
+        return key;
+      }
+    }
+  };
+
+  const getClient = () => {
+    return (client ??= new UTApi({
+      apiKey: opts.apiKey,
+      fetch: ofetch.native,
+      logLevel: "debug",
+    }));
+  };
+
+  // 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,
+      },
+    }));
+  };
+
+  const getUTFsFetch = () => {
+    return (utFsFetch ??= ofetch.create({
+      baseURL: "https://utfs.io/f",
+    }));
+  };
+
+  return {
+    hasItem(key) {
+      const utkey = internalToUTKeyMap.get(key);
+      if (!utkey) return false;
+      // This is the best endpoint we got currently...
+      return getUTApiFetch()("/getFileUrl", {
+        body: { fileKeys: [utkey] },
+      }).then((res) => {
+        return !!res?.data?.length;
+      });
+    },
+    getItem(key) {
+      const utkey = internalToUTKeyMap.get(key);
+      if (!utkey) return null;
+      return getUTFsFetch()(`/${utkey}`).then((r) => r.text());
+    },
+    getKeys() {
+      return getClient()
+        .listFiles({})
+        .then((res) => res.map((file) => fromUTKey(file.key) ?? file.key));
+    },
+    setItem(key, value, opts) {
+      return getClient()
+        .uploadFiles(Object.assign(new Blob([value]), { name: key }), {
+          metadata: opts?.metadata,
+        })
+        .then((response) => {
+          if (response.error) throw response.error;
+          internalToUTKeyMap.set(key, response.data.key);
+        });
+    },
+    setItems(items, opts) {
+      return getClient()
+        .uploadFiles(
+          items.map((item) =>
+            Object.assign(new Blob([item.value]), { name: item.key })
+          ),
+          { metadata: opts?.metadata }
+        )
+        .then((responses) => {
+          responses.map((response) => {
+            if (response.error) throw response.error;
+            internalToUTKeyMap.set(response.data.name, response.data.key);
+          });
+        });
+    },
+    removeItem(key, opts) {
+      const utkey = internalToUTKeyMap.get(key);
+      if (!utkey) throw new Error(`Unknown key: ${key}`);
+      return getClient()
+        .deleteFiles([utkey])
+        .then(() => {
+          internalToUTKeyMap.delete(key);
+        });
+    },
+    async clear() {
+      const utkeys = Array.from(internalToUTKeyMap.values());
+      return getClient()
+        .deleteFiles(utkeys)
+        .then(() => {
+          internalToUTKeyMap.clear();
+        });
+    },
+
+    // getMeta(key, opts) {
+    //   // TODO: We don't currently have an endpoint to fetch metadata, but it does exist
+    // },
+  };
+});

test/drivers/uploadthing.test.ts

@@ -0,0 +1,81 @@
+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_4603822c7c4574cc90495ff3b31204adf20311bc953903d8081be7a5176f31aa",
+      }),
+      async additionalTests(ctx) {},
+    });
+  },
+  { timeout: 30e3 }
+);