feat(drivers): enhance drivers with typed options for get, set, remove, and list operations via generation

scripts/gen-drivers.ts

@@ -3,6 +3,13 @@ import { join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { findTypeExports } from "mlly";
 import { camelCase, upperFirst } from "scule";
+import type { SafeName } from "../src";
+
+function getSafeName<T extends string>(name: T): SafeName<T> {
+  return camelCase(name)
+    .replace(/kv/i, "KV")
+    .replace("localStorage", "localstorage") as SafeName<T>;
+}
 
 const driversDir = fileURLToPath(new URL("../src/drivers", import.meta.url));
 
@@ -23,6 +30,8 @@ const drivers: {
   subpath: string;
   optionsTExport?: string;
   optionsTName?: string;
+  driverOptionsExport?: string;
+  driverName?: string;
 }[] = [];
 
 for (const entry of driverEntries) {
@@ -31,25 +40,33 @@ for (const entry of driverEntries) {
   const fullPath = join(driversDir, `${name}.ts`);
 
   const contents = await readFile(fullPath, "utf8");
-  const optionsTExport = findTypeExports(contents).find((type) =>
+  const typeExports = findTypeExports(contents);
+  const optionsTExport = typeExports.find((type) =>
     type.name?.endsWith("Options")
   )?.name;
 
-  const safeName = camelCase(name)
-    .replace(/kv/i, "KV")
-    .replace("localStorage", "localstorage");
+  const driverOptionsExport = typeExports.find((type) =>
+    type.name?.endsWith("Driver")
+  )?.name;
+
+  const safeName = getSafeName(name);
 
   const names = [...new Set([name, safeName])];
 
+  // TODO: due to name + safe name, options are duplicated for same driver which is confusing a bit tedious to pass options (e.g. deno-kv or denoKV?) -> currently only (deno-kv works but denoKV is typed)
   const optionsTName = upperFirst(safeName) + "Options";
 
+  const driverName = upperFirst(safeName) + "Driver";
+
   drivers.push({
     name,
     safeName,
     names,
     subpath,
     optionsTExport,
     optionsTName,
+    driverOptionsExport,
+    driverName,
   });
 }
 
@@ -64,6 +81,14 @@ ${drivers
   )
   .join("\n")}
 
+${drivers
+  .filter((d) => d.driverOptionsExport)
+  .map(
+    (d) =>
+      /* ts */ `import type { ${d.driverOptionsExport} as ${d.driverName} } from "${d.subpath}";`
+  )
+  .join("\n")}
+
 export type BuiltinDriverName = ${drivers.flatMap((d) => d.names.map((name) => `"${name}"`)).join(" | ")};
 
 export type BuiltinDriverOptions = {
@@ -76,6 +101,61 @@ export type BuiltinDriverOptions = {
 export const builtinDrivers = {
   ${drivers.flatMap((d) => d.names.map((name) => `"${name}": "${d.subpath}"`)).join(",\n  ")},
 } as const;
+
+export type BuiltinDrivers = {
+  ${drivers
+    .filter((d) => d.driverOptionsExport)
+    .flatMap((d) => d.names.map((name) => `"${name}": ${d.driverName};`))
+    .join("\n  ")}
+}
+
+export type DriverGetOptions = {
+  ${drivers
+    .filter((d) => d.driverOptionsExport)
+    .flatMap((d) =>
+      d.names.map(
+        (name) =>
+          `"${name}"?: ${d.driverName} extends { getOptions: infer TGet } ? unknown extends TGet ? {} : TGet : {}`
+      )
+    )
+    .join("\n  ")}
+}
+
+export type DriverSetOptions = {
+  ${drivers
+    .filter((d) => d.driverOptionsExport)
+    .flatMap((d) =>
+      d.names.map(
+        (name) =>
+          `"${name}"?: ${d.driverName} extends { setOptions: infer TSet } ? unknown extends TSet ? {} : TSet : {}`
+      )
+    )
+    .join("\n  ")}
+}
+
+export type DriverRemoveOptions = {
+  ${drivers
+    .filter((d) => d.driverOptionsExport)
+    .flatMap((d) =>
+      d.names.map(
+        (name) =>
+          `"${name}"?: ${d.driverName} extends { removeOptions: infer TRemove } ? unknown extends TRemove ? {} : TRemove : {}`
+      )
+    )
+    .join("\n  ")}
+}
+
+export type DriverListOptions = {
+  ${drivers
+    .filter((d) => d.driverOptionsExport)
+    .flatMap((d) =>
+      d.names.map(
+        (name) =>
+          `"${name}"?: ${d.driverName} extends { listOptions: infer TList } ? unknown extends TList ? {} : TList : {}`
+      )
+    )
+    .join("\n  ")}
+}
 `;
 
 await writeFile(driversMetaFile, genCode, "utf8");

src/_drivers.ts

@@ -33,6 +33,8 @@ import type { VercelBlobOptions as VercelBlobOptions } from "unstorage/drivers/v
 import type { VercelKVOptions as VercelKVOptions } from "unstorage/drivers/vercel-kv";
 import type { VercelCacheOptions as VercelRuntimeCacheOptions } from "unstorage/drivers/vercel-runtime-cache";
 
+import type { DenoKvDriver as DenoKVDriver } from "unstorage/drivers/deno-kv";
+
 export type BuiltinDriverName = "azure-app-configuration" | "azureAppConfiguration" | "azure-cosmos" | "azureCosmos" | "azure-key-vault" | "azureKeyVault" | "azure-storage-blob" | "azureStorageBlob" | "azure-storage-table" | "azureStorageTable" | "capacitor-preferences" | "capacitorPreferences" | "cloudflare-kv-binding" | "cloudflareKVBinding" | "cloudflare-kv-http" | "cloudflareKVHttp" | "cloudflare-r2-binding" | "cloudflareR2Binding" | "db0" | "deno-kv-node" | "denoKVNode" | "deno-kv" | "denoKV" | "fs-lite" | "fsLite" | "fs" | "github" | "http" | "indexedb" | "localstorage" | "lru-cache" | "lruCache" | "memory" | "mongodb" | "netlify-blobs" | "netlifyBlobs" | "null" | "overlay" | "planetscale" | "redis" | "s3" | "session-storage" | "sessionStorage" | "uploadthing" | "upstash" | "vercel-blob" | "vercelBlob" | "vercel-kv" | "vercelKV" | "vercel-runtime-cache" | "vercelRuntimeCache";
 
 export type BuiltinDriverOptions = {
@@ -140,3 +142,28 @@ export const builtinDrivers = {
   "vercel-runtime-cache": "unstorage/drivers/vercel-runtime-cache",
   "vercelRuntimeCache": "unstorage/drivers/vercel-runtime-cache",
 } as const;
+
+export type BuiltinDrivers = {
+  "deno-kv": DenoKVDriver;
+  "denoKV": DenoKVDriver;
+}
+
+export type DriverGetOptions = {
+  "deno-kv"?: DenoKVDriver extends { getOptions: infer TGet } ? unknown extends TGet ? {} : TGet : {}
+  "denoKV"?: DenoKVDriver extends { getOptions: infer TGet } ? unknown extends TGet ? {} : TGet : {}
+}
+
+export type DriverSetOptions = {
+  "deno-kv"?: DenoKVDriver extends { setOptions: infer TSet } ? unknown extends TSet ? {} : TSet : {}
+  "denoKV"?: DenoKVDriver extends { setOptions: infer TSet } ? unknown extends TSet ? {} : TSet : {}
+}
+
+export type DriverRemoveOptions = {
+  "deno-kv"?: DenoKVDriver extends { removeOptions: infer TRemove } ? unknown extends TRemove ? {} : TRemove : {}
+  "denoKV"?: DenoKVDriver extends { removeOptions: infer TRemove } ? unknown extends TRemove ? {} : TRemove : {}
+}
+
+export type DriverListOptions = {
+  "deno-kv"?: DenoKVDriver extends { listOptions: infer TList } ? unknown extends TList ? {} : TList : {}
+  "denoKV"?: DenoKVDriver extends { listOptions: infer TList } ? unknown extends TList ? {} : TList : {}
+}

src/drivers/deno-kv.ts

@@ -1,3 +1,4 @@
+import type { InferOperationOptions } from "../types";
 import { defineDriver, createError, normalizeKey } from "./utils/index";
 import type { Kv, KvKey } from "@deno/kv";
 
@@ -12,15 +13,17 @@ export interface DenoKvOptions {
    */
   ttl?: number;
 }
-interface DenoKVSetOptions {
-  /**
-   * TTL in seconds.
-   */
-  ttl?: number;
+
+export interface DenoKvDriver {
+  setOptions: {};
+  getOptions: {};
+  removeOptions: {};
 }
 
 const DRIVER_NAME = "deno-kv";
 
+type MethodTypes = InferOperationOptions<DenoKvDriver, typeof DRIVER_NAME>;
+
 export default defineDriver<DenoKvOptions, Promise<Deno.Kv | Kv>>(
   (opts: DenoKvOptions = {}) => {
     const basePrefix: KvKey = opts.base
@@ -75,12 +78,12 @@ export default defineDriver<DenoKvOptions, Promise<Deno.Kv | Kv>>(
         const value = await kv.get(r(key));
         return value.value;
       },
-      async setItem(key, value, tOptions: DenoKVSetOptions) {
+      async setItem(key, value, tOptions: MethodTypes["setOptions"]) {
         const ttl = normalizeTTL(tOptions?.ttl ?? opts?.ttl);
         const kv = await getKv();
         await kv.set(r(key), value, { expireIn: ttl });
       },
-      async setItemRaw(key, value, tOptions: DenoKVSetOptions) {
+      async setItemRaw(key, value, tOptions: MethodTypes["setOptions"]) {
         const ttl = normalizeTTL(tOptions?.ttl ?? opts?.ttl);
         const kv = await getKv();
         await kv.set(r(key), value, { expireIn: ttl });