@bunit/storage 0.0.0 → 0.0.1

package/README.md

@@ -0,0 +1,80 @@
+# @bunit/storage
+
+![npm version](https://img.shields.io/npm/v/@bunit/storage)
+![npm downloads](https://img.shields.io/npm/dw/@bunit/storage)
+![npm license](https://img.shields.io/npm/l/@bunit/storage)
+
+> 🔌 Native Bun drivers for [**unstorage**](https://unstorage.unjs.io) - Filesystem, Redis, and S3.
+
+## Features
+
+- ⚡️ **Native Bun APIs** - Zero abstraction overhead using Bun's built-in clients
+- 🔌 **Unstorage Compatible** - Drop-in drivers for any unstorage setup
+- 🎯 **Type-Safe** - Full TypeScript support with proper types
+- 📦 **Zero Runtime Dependencies** - Uses only Bun's native capabilities
+
+## Installation
+
+```bash
+bun add @bunit/storage unstorage
+```
+
+## Usage
+
+### Filesystem Driver
+
+```typescript
+import { createStorage } from "unstorage";
+import fsDriver from "@bunit/storage/drivers/fs";
+
+const storage = createStorage({
+  driver: fsDriver({
+    base: "./data",
+    ignore: ["node_modules", ".git"],
+  }),
+});
+
+await storage.setItem("config:user", JSON.stringify({ name: "Alice" }));
+const data = await storage.getItem("config:user");
+```
+
+### Redis Driver
+
+```typescript
+import { createStorage } from "unstorage";
+import redisDriver from "@bunit/storage/drivers/redis";
+
+const storage = createStorage({
+  driver: redisDriver({
+    url: "redis://localhost:6379",
+    base: "app:cache",
+    ttl: 3600, // 1 hour default TTL
+  }),
+});
+
+await storage.setItem("session:123", "data");
+```
+
+### S3 Driver
+
+```typescript
+import { createStorage } from "unstorage";
+import s3Driver from "@bunit/storage/drivers/s3";
+
+const storage = createStorage({
+  driver: s3Driver({
+    accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+    bucket: "my-bucket",
+    region: "us-east-1",
+    endpoint: "https://s3.us-east-1.amazonaws.com",
+    base: "prefix/",
+  }),
+});
+
+await storage.setItem("uploads/image.png", buffer);
+```
+
+## License
+
+[MIT](../../LICENSE) © [Demo Macro](https://www.demomacro.com/)

package/dist/drivers/fs.d.ts

@@ -1,6 +1,7 @@
+import type { Driver } from "unstorage";
 export interface FSDriverOptions {
     base?: string;
     ignore?: string | string[];
 }
-declare const _default: (opts: FSDriverOptions) => import("unstorage").Driver<FSDriverOptions, never>;
+declare const _default: (opts: FSDriverOptions) => Driver<FSDriverOptions, any>;
 export default _default;

package/dist/drivers/fs.mjs

@@ -1,5 +1,5 @@
 import { defineDriver, normalizeKey } from "unstorage";
-import { mkdir } from "node:fs/promises";
+import { mkdir, rm } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
 import { Glob } from "bun";
 export default defineDriver((options = {}) => {
@@ -7,29 +7,50 @@ export default defineDriver((options = {}) => {
   return {
     name: "fs",
     options,
-    hasItem(key) {
+    hasItem(key, _opts) {
       const path = join(base, key.replace(/:/g, "/"));
       return Bun.file(path).exists();
     },
-    async getItem(key) {
+    async getItem(key, _opts) {
       const path = join(base, key.replace(/:/g, "/")), file = Bun.file(path);
       if (!await file.exists())
         return null;
       return await file.text();
     },
-    async setItem(key, value) {
+    async getItemRaw(key, _opts) {
+      const path = join(base, key.replace(/:/g, "/")), file = Bun.file(path);
+      if (!await file.exists())
+        return null;
+      return await file.arrayBuffer();
+    },
+    async setItem(key, value, _opts) {
+      const path = join(base, key.replace(/:/g, "/"));
+      await mkdir(dirname(path), { recursive: !0 });
+      await Bun.write(path, value);
+    },
+    async setItemRaw(key, value, _opts) {
       const path = join(base, key.replace(/:/g, "/"));
       await mkdir(dirname(path), { recursive: !0 });
       await Bun.write(path, value);
     },
-    async removeItem(key) {
+    async removeItem(key, _opts) {
       const path = join(base, key.replace(/:/g, "/"));
       await Bun.file(path).delete();
     },
-    async getKeys() {
-      const glob = new Glob("**/*"), keys = [];
-      for await (const file of glob.scan(base)) {
-        const key = normalizeKey(file);
+    async getMeta(key, _opts) {
+      const path = join(base, key.replace(/:/g, "/"));
+      if (!await Bun.file(path).exists())
+        return null;
+      const stat = await Bun.file(path).stat();
+      return {
+        mtime: stat.mtime,
+        size: stat.size
+      };
+    },
+    async getKeys(baseKey, _opts) {
+      const glob = new Glob("**/*"), keys = [], scanPath = baseKey ? join(base, baseKey.replace(/:/g, "/")) : base;
+      for await (const file of glob.scan(scanPath)) {
+        const relativePath = baseKey ? file.replace(baseKey.replace(/:/g, "/") + "/", "") : file, key = normalizeKey(relativePath);
         if (ignore.length > 0) {
           if (Array.isArray(ignore) ? ignore.some((pattern) => file.includes(pattern)) : file.includes(ignore))
             continue;
@@ -38,12 +59,11 @@ export default defineDriver((options = {}) => {
       }
       return keys;
     },
-    async clear() {
-      const glob = new Glob("**/*");
-      for await (const file of glob.scan(base)) {
-        const path = join(base, file);
-        await Bun.file(path).delete();
-      }
+    async clear(baseKey, _opts) {
+      const targetPath = baseKey ? join(base, baseKey.replace(/:/g, "/")) : base;
+      try {
+        await rm(targetPath, { recursive: !0, force: !0 });
+      } catch {}
     },
     async dispose() {}
   };

package/dist/drivers/redis.d.ts

@@ -0,0 +1,20 @@
+import type { Driver } from "unstorage";
+import { RedisClient, type RedisOptions } from "bun";
+export interface RedisDriverOptions extends RedisOptions {
+    /**
+     * Connection URL for Redis.
+     * Format: `redis://username:password@localhost:6379`
+     * Defaults to `redis://localhost:6379`
+     */
+    url?: string;
+    /**
+     * Optional prefix to use for all keys.
+     */
+    base?: string;
+    /**
+     * Default TTL for all items in seconds.
+     */
+    ttl?: number;
+}
+declare const _default: (opts: RedisDriverOptions) => Driver<RedisDriverOptions, RedisClient>;
+export default _default;

package/dist/drivers/redis.mjs

@@ -0,0 +1,94 @@
+import { defineDriver, normalizeKey } from "unstorage";
+import { RedisClient } from "bun";
+export default defineDriver((options = {}) => {
+  let client;
+  const getClient = () => {
+    if (!client)
+      client = new RedisClient(options.url, options);
+    return client;
+  }, base = (options.base || "").replace(/:$/, ""), p = (key) => base ? `${base}:${key}` : key, d = (key) => base ? key.replace(`${base}:`, "") : key;
+  return {
+    name: "redis",
+    options,
+    getInstance: getClient,
+    async hasItem(key, _opts) {
+      const exists = await getClient().exists(p(key));
+      return typeof exists === "number" ? exists > 0 : exists;
+    },
+    async getItem(key, _opts) {
+      return await getClient().get(p(key)) ?? null;
+    },
+    async getItems(items, _commonOpts) {
+      const keys = items.map((item) => p(item.key)), values = await getClient().mget(...keys);
+      return keys.map((key, index) => ({
+        key: d(key),
+        value: values[index] ?? null
+      }));
+    },
+    async getItemRaw(key, _opts) {
+      return await getClient().getBuffer(p(key));
+    },
+    async setItem(key, value, _opts) {
+      const client = getClient();
+      if (options.ttl) {
+        await client.set(p(key), value);
+        await client.expire(p(key), options.ttl);
+      } else
+        await client.set(p(key), value);
+    },
+    async setItems(items, _opts) {
+      const client = getClient(), pipeline = [];
+      for (const item of items) {
+        pipeline.push(client.set(p(item.key), item.value));
+        if (options.ttl)
+          pipeline.push(client.expire(p(item.key), options.ttl));
+      }
+      await Promise.allSettled(pipeline);
+    },
+    async setItemRaw(key, value, _opts) {
+      const client = getClient();
+      if (typeof value === "string")
+        await client.set(p(key), value);
+      else
+        await client.set(p(key), value);
+      if (options.ttl)
+        await client.expire(p(key), options.ttl);
+    },
+    async removeItem(key, _opts) {
+      await getClient().del(p(key));
+    },
+    async getMeta(key, _opts) {
+      const ttl = await getClient().ttl(p(key));
+      if (!await getClient().exists(p(key)))
+        return null;
+      return {
+        ttl: ttl > 0 ? ttl : void 0
+      };
+    },
+    async getKeys(baseKey, _opts) {
+      const keys = [];
+      let cursor = 0;
+      const pattern = p(baseKey + "*");
+      do {
+        const result = await getClient().scan(cursor, "MATCH", pattern);
+        cursor = typeof result[0] === "number" ? result[0] : parseInt(result[0], 10);
+        const scanKeys = result[1];
+        keys.push(...scanKeys);
+      } while (cursor !== 0);
+      return keys.map((key) => normalizeKey(d(key)));
+    },
+    async clear(base, _opts) {
+      const keys = await this.getKeys(base, _opts);
+      if (keys.length === 0)
+        return;
+      const client = getClient(), keysToDelete = keys.map((key) => p(key));
+      if (keysToDelete.length === 1)
+        await client.del(keysToDelete[0]);
+      else
+        await client.del(...keysToDelete);
+    },
+    async dispose() {
+      client = void 0;
+    }
+  };
+});

package/dist/drivers/s3.d.ts

@@ -0,0 +1,10 @@
+import type { Driver } from "unstorage";
+import { S3Client, type S3Options } from "bun";
+export interface S3DriverOptions extends S3Options {
+    /**
+     * Optional prefix to use for all keys.
+     */
+    base?: string;
+}
+declare const _default: (opts: S3DriverOptions) => Driver<S3DriverOptions, S3Client>;
+export default _default;

package/dist/drivers/s3.mjs

@@ -0,0 +1,96 @@
+import { defineDriver, normalizeKey } from "unstorage";
+import { S3Client } from "bun";
+export default defineDriver((options) => {
+  let client;
+  const getClient = () => {
+    if (!client)
+      client = new S3Client(options);
+    return client;
+  }, base = (options.base || "").replace(/\/$/, ""), p = (key) => base ? `${base}/${normalizeKey(key)}` : normalizeKey(key), d = (key) => base ? key.replace(`${base}/`, "") : key;
+  return {
+    name: "s3",
+    options,
+    getInstance: getClient,
+    async hasItem(key, _opts) {
+      try {
+        await getClient().file(p(key)).exists();
+        return !0;
+      } catch {
+        return !1;
+      }
+    },
+    async getItem(key, _opts) {
+      try {
+        return await getClient().file(p(key)).text();
+      } catch {
+        return null;
+      }
+    },
+    async getItemRaw(key, _opts) {
+      try {
+        return await getClient().file(p(key)).bytes();
+      } catch {
+        return null;
+      }
+    },
+    async setItem(key, value, _opts) {
+      await getClient().file(p(key)).write(value);
+    },
+    async setItemRaw(key, value, _opts) {
+      await getClient().file(p(key)).write(value);
+    },
+    async removeItem(key, _opts) {
+      await getClient().file(p(key)).delete();
+    },
+    async getMeta(key, _opts) {
+      try {
+        const result = await S3Client.list({ prefix: p(key) }, options);
+        if (result.contents && result.contents.length > 0) {
+          const object = result.contents[0];
+          return {
+            size: object.size,
+            mtime: object.lastModified ? new Date(object.lastModified) : void 0,
+            etag: object.eTag
+          };
+        }
+        return null;
+      } catch {
+        return null;
+      }
+    },
+    async getKeys(baseKey, _opts) {
+      const keys = [];
+      let startAfter = void 0;
+      const prefix = p(baseKey || "");
+      let hasMore = !0;
+      while (hasMore) {
+        const result = await S3Client.list({
+          prefix,
+          startAfter,
+          maxKeys: 1000
+        }, options);
+        if (result.contents)
+          for (const object of result.contents) {
+            const relativeKey = d(object.key);
+            keys.push(normalizeKey(relativeKey));
+          }
+        if (result.isTruncated && result.contents && result.contents.length > 0)
+          startAfter = result.contents[result.contents.length - 1].key;
+        else
+          hasMore = !1;
+      }
+      return keys;
+    },
+    async clear(baseKey, _opts) {
+      const keys = await this.getKeys(baseKey, _opts);
+      if (keys.length === 0)
+        return;
+      await Promise.allSettled(keys.map(async (key) => {
+        await getClient().file(p(key)).delete();
+      }));
+    },
+    async dispose() {
+      client = void 0;
+    }
+  };
+});

package/package.json

@@ -1,8 +1,18 @@
 {
   "name": "@bunit/storage",
-  "version": "0.0.0",
-  "description": "",
-  "keywords": [],
+  "version": "0.0.1",
+  "description": "Universal storage abstraction with native Bun drivers for filesystem, Redis, and S3",
+  "keywords": [
+    "bun",
+    "cloudflare",
+    "driver",
+    "filesystem",
+    "r2",
+    "redis",
+    "s3",
+    "storage",
+    "unstorage"
+  ],
   "homepage": "https://github.com/DemoMacro/BunIt#readme",
   "bugs": {
     "url": "https://github.com/DemoMacro/BunIt/issues"