From 88f41aba505f25665fa06d810642310076479920 Mon Sep 17 00:00:00 2001
From: Antoine Monnet <monnet.antoine@gmail.com>
Date: Thu, 30 Jan 2025 10:50:53 +0100
Subject: [PATCH] feat(url): add a bundle for all drivers

---
 src/loader/_utils.ts | 14 +++++++++++++
 src/loader/all.ts    | 48 ++++++++++++++++++++++++++++++++++++++++++++
 src/types.ts         |  4 ++++
 test/loader.test.ts  |  6 ++++++
 4 files changed, 72 insertions(+)
 create mode 100644 src/loader/all.ts

diff --git a/src/loader/_utils.ts b/src/loader/_utils.ts
index ea8239ac..3c2ffe45 100644
--- a/src/loader/_utils.ts
+++ b/src/loader/_utils.ts
@@ -1,3 +1,5 @@
+import type { Driver, AsyncDriverFactory } from "../types";
+
 export function coerceQuery(query: Record<string, string | string[]>) {
   return Object.fromEntries(
     Object.entries(query).map(([key, value]: [string, string | string[]]) => {
@@ -17,3 +19,15 @@ function coerceValue(value: string | string[]): any {
     return value;
   }
 }
+
+export function factoryLoader<OptionsT, InstanceT>(
+  loader: () => any
+): AsyncDriverFactory<OptionsT, InstanceT> {
+  async function dynamicFactory(
+    options: OptionsT
+  ): Promise<Driver<OptionsT, InstanceT>> {
+    const factory = (await loader()).default;
+    return factory(options);
+  }
+  return dynamicFactory;
+}
diff --git a/src/loader/all.ts b/src/loader/all.ts
new file mode 100644
index 00000000..c18c8eae
--- /dev/null
+++ b/src/loader/all.ts
@@ -0,0 +1,48 @@
+import { factoryLoader } from "./_utils";
+
+const all = {
+  "azure+appconfigarution": factoryLoader(
+    () => import("../drivers/azure-app-configuration")
+  ),
+  "azure+cosmos": factoryLoader(() => import("../drivers/azure-cosmos")),
+  "azure+keyvault": factoryLoader(() => import("../drivers/azure-key-vault")),
+  "azure+blob": factoryLoader(() => import("../drivers/azure-storage-blob")),
+  "azure+table": factoryLoader(() => import("../drivers/azure-storage-table")),
+  "capacitor+preferences": factoryLoader(
+    () => import("../drivers/capacitor-preferences")
+  ),
+  "cloudflarekv+binding": factoryLoader(
+    () => import("../drivers/cloudflare-kv-binding")
+  ),
+  "cloudflarekv+http": factoryLoader(
+    () => import("../drivers/cloudflare-kv-http")
+  ),
+  "cloudflarer2+binding": factoryLoader(
+    () => import("../drivers/cloudflare-r2-binding")
+  ),
+  db: factoryLoader(() => import("../drivers/db0")),
+  "denokv+node": factoryLoader(() => import("../drivers/deno-kv-node")),
+  denokv: factoryLoader(() => import("../drivers/deno-kv")),
+  file: factoryLoader(() => import("../drivers/fs")),
+  github: factoryLoader(() => import("../drivers/github")),
+  http: factoryLoader(() => import("../drivers/http")),
+  https: factoryLoader(() => import("../drivers/http")),
+  indexedb: factoryLoader(() => import("../drivers/indexedb")),
+  localstorage: factoryLoader(() => import("../drivers/localstorage")),
+  cache: factoryLoader(() => import("../drivers/lru-cache")),
+  memory: factoryLoader(() => import("../drivers/memory")),
+  mongodb: factoryLoader(() => import("../drivers/mongodb")),
+  "netlify+blobs": factoryLoader(() => import("../drivers/netlify-blobs")),
+  null: factoryLoader(() => import("../drivers/null")),
+  overlay: factoryLoader(() => import("../drivers/overlay")),
+  planetscale: factoryLoader(() => import("../drivers/planetscale")),
+  redis: factoryLoader(() => import("../drivers/redis")),
+  s3: factoryLoader(() => import("../drivers/s3")),
+  sessionstorage: factoryLoader(() => import("../drivers/session-storage")),
+  uploadthing: factoryLoader(() => import("../drivers/uploadthing")),
+  upstash: factoryLoader(() => import("../drivers/upstash")),
+  "vercel+blob": factoryLoader(() => import("../drivers/vercel-blob")),
+  "vercel+kv": factoryLoader(() => import("../drivers/vercel-kv")),
+};
+
+export default all;
diff --git a/src/types.ts b/src/types.ts
index 0b79f30c..d80dac36 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -75,6 +75,10 @@ export type DriverFactory<OptionsT, InstanceT> = (
   opts: OptionsT
 ) => Driver<OptionsT, InstanceT>;
 
+export type AsyncDriverFactory<OptionsT, InstanceT> = (
+  opts: OptionsT
+) => Promise<Driver<OptionsT, InstanceT>>;
+
 type StorageDefinition = {
   items: unknown;
   [key: string]: unknown;
diff --git a/test/loader.test.ts b/test/loader.test.ts
index e44fc942..5aa98b24 100644
--- a/test/loader.test.ts
+++ b/test/loader.test.ts
@@ -1,6 +1,7 @@
 import { describe, it, expect } from "vitest";
 import { defineDriver } from "../src";
 import { loadFromUrl } from "../src/loader";
+import all from "../src/loader/all";
 
 interface Options {
   scheme: string;
@@ -47,4 +48,9 @@ describe("loader", () => {
     expect(driver.options.array).toStrictEqual([2, 3, 4]);
     expect(driver.options.object).toStrictEqual({ h: 5, i: 6, j: "7" });
   });
+
+  it("all bundle", async () => {
+    const driver = await loadFromUrl("memory:", all);
+    expect(driver.name).toBe("memory");
+  });
 });