@stacksjs/storage 0.70.87 → 0.70.90

package/dist/adapters/bun.js

@@ -0,0 +1,226 @@
+import { Buffer } from "node:buffer";
+import { file, write as bunWrite } from "bun";
+import { chmod, lstat } from "node:fs/promises";
+import { basename, dirname, join, relative } from "node:path";
+import { createDirectoryListing, normalizeExpiryToDate } from "../types";
+import { createSignedStorageToken } from "../signed-url";
+
+export class BunStorageAdapter {
+  root;
+  constructor(config = {}) {
+    this.root = config.root || process.cwd();
+  }
+  resolvePath(path) {
+    const resolved = join(this.root, path), rel = relative(this.root, resolved);
+    if (rel.startsWith("..") || rel.startsWith("../") || rel.startsWith("..\\"))
+      throw Error(`Path traversal detected: '${path}' resolves outside storage root`);
+    return resolved;
+  }
+  async write(path, contents) {
+    const fullPath = this.resolvePath(path), dir = dirname(fullPath);
+    await this.createDirectory(relative(this.root, dir));
+    if (typeof contents === "string")
+      await bunWrite(fullPath, contents);
+    else if (contents instanceof Buffer)
+      await bunWrite(fullPath, contents);
+    else if (contents instanceof Uint8Array)
+      await bunWrite(fullPath, contents);
+    else {
+      if (typeof contents.getReader !== "function")
+        throw TypeError("[storage/bun] contents must be a web-standard ReadableStream (with .getReader()), not a Node stream.Readable. Convert via Readable.toWeb(nodeStream) before passing.");
+      const reader = contents.getReader(), chunks = [];
+      while (!0) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        if (value)
+          chunks.push(value);
+      }
+      const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0), result = new Uint8Array(totalLength);
+      let offset = 0;
+      for (const chunk of chunks) {
+        result.set(chunk, offset);
+        offset += chunk.length;
+      }
+      await bunWrite(fullPath, result);
+    }
+    const written = file(fullPath);
+    return {
+      path,
+      size: written.size,
+      lastModified: written.lastModified
+    };
+  }
+  async read(path) {
+    const fullPath = this.resolvePath(path), bunFile = file(fullPath);
+    if (!await bunFile.exists())
+      throw Error(`File not found: ${path}`);
+    return await bunFile.arrayBuffer().then((buf) => new Uint8Array(buf));
+  }
+  async getStream(path, _options) {
+    const fullPath = this.resolvePath(path), bunFile = file(fullPath);
+    if (!await bunFile.exists())
+      throw Error(`File not found: ${path}`);
+    return bunFile.stream();
+  }
+  async putStream(path, stream, options) {
+    const fullPath = this.resolvePath(path), dir = dirname(fullPath);
+    await this.createDirectory(relative(this.root, dir));
+    try {
+      const body = new Response(stream), writePromise = bunWrite(fullPath, body);
+      if (options?.signal) {
+        const abortHandler = () => {};
+        options.signal.addEventListener("abort", abortHandler, { once: !0 });
+        try {
+          await writePromise;
+        } finally {
+          options.signal.removeEventListener("abort", abortHandler);
+        }
+      } else
+        await writePromise;
+    } catch (err) {
+      try {
+        await Bun.$.throws(!1)`rm -f ${fullPath}`;
+      } catch {}
+      throw err;
+    }
+    const written = file(fullPath);
+    return {
+      path,
+      size: written.size,
+      contentType: options?.contentType,
+      lastModified: written.lastModified
+    };
+  }
+  async readToString(path) {
+    const fullPath = this.resolvePath(path), bunFile = file(fullPath);
+    if (!await bunFile.exists())
+      throw Error(`File not found: ${path}`);
+    return await bunFile.text();
+  }
+  async readToBuffer(path) {
+    const fullPath = this.resolvePath(path), bunFile = file(fullPath);
+    if (!await bunFile.exists())
+      throw Error(`File not found: ${path}`);
+    const arrayBuffer = await bunFile.arrayBuffer();
+    return Buffer.from(arrayBuffer);
+  }
+  async readToUint8Array(path) {
+    const fullPath = this.resolvePath(path), bunFile = file(fullPath);
+    if (!await bunFile.exists())
+      throw Error(`File not found: ${path}`);
+    const arrayBuffer = await bunFile.arrayBuffer();
+    return new Uint8Array(arrayBuffer);
+  }
+  async deleteFile(path) {
+    const fullPath = this.resolvePath(path);
+    if (await file(fullPath).exists())
+      await Bun.$.throws(!1)`rm ${fullPath}`;
+  }
+  async deleteDirectory(path) {
+    const fullPath = this.resolvePath(path);
+    await Bun.$.throws(!1)`rm -rf ${fullPath}`;
+  }
+  async createDirectory(path) {
+    const fullPath = this.resolvePath(path);
+    await Bun.$.throws(!1)`mkdir -p ${fullPath}`;
+  }
+  async moveFile(from, to) {
+    const fromPath = this.resolvePath(from), toPath = this.resolvePath(to), toDir = dirname(toPath);
+    await this.createDirectory(relative(this.root, toDir));
+    await Bun.$.throws(!0)`mv ${fromPath} ${toPath}`;
+  }
+  async copyFile(from, to) {
+    const fromPath = this.resolvePath(from), toPath = this.resolvePath(to), toDir = dirname(toPath);
+    await this.createDirectory(relative(this.root, toDir));
+    await Bun.$.throws(!0)`cp ${fromPath} ${toPath}`;
+  }
+  async stat(path) {
+    const fullPath = this.resolvePath(path), bunFile = file(fullPath);
+    if (!await bunFile.exists())
+      throw Error(`File not found: ${path}`);
+    const stats = await Bun.file(fullPath).stat(), isDir = stats.isDirectory();
+    return {
+      path,
+      type: isDir ? "directory" : "file",
+      visibility: "private",
+      size: isDir ? 0 : stats.size,
+      lastModified: stats.mtime?.getTime() || Date.now(),
+      mimeType: isDir ? void 0 : bunFile.type
+    };
+  }
+  list(path, options = {}) {
+    const fullPath = this.resolvePath(path);
+    return this.createAsyncIterator(fullPath, options.deep || !1);
+  }
+  async* createAsyncIterator(dirPath, deep) {
+    const entries = [];
+    try {
+      const glob = new Bun.Glob(deep ? "**/*" : "*");
+      for await (const entry of glob.scan({ cwd: dirPath, onlyFiles: !1 })) {
+        const fullEntryPath = join(dirPath, entry), stats = await Bun.file(fullEntryPath).stat();
+        entries.push({
+          path: relative(this.root, fullEntryPath),
+          type: stats.isDirectory() ? "directory" : "file"
+        });
+      }
+    } catch (error) {
+      return;
+    }
+    yield* createDirectoryListing(entries);
+  }
+  async changeVisibility(path, vis) {
+    const fullPath = this.resolvePath(path), isDir = (await lstat(fullPath)).isDirectory();
+    await chmod(fullPath, vis === "public" ? isDir ? 493 : 420 : isDir ? 448 : 384);
+  }
+  async visibility(path) {
+    const fullPath = this.resolvePath(path);
+    return (await lstat(fullPath)).mode & 511 & 4 ? "public" : "private";
+  }
+  async fileExists(path) {
+    const fullPath = this.resolvePath(path);
+    return await file(fullPath).exists();
+  }
+  async directoryExists(path) {
+    const fullPath = this.resolvePath(path);
+    try {
+      return (await Bun.file(fullPath).stat()).isDirectory();
+    } catch {
+      return !1;
+    }
+  }
+  async publicUrl(path, options = {}) {
+    return `${options.domain || "http://localhost"}/${path}`;
+  }
+  async temporaryUrl(path, options) {
+    const expiry = normalizeExpiryToDate(options.expiresIn);
+    return `http://localhost/temp/${Buffer.from(`${path}:${expiry.getTime()}`).toString("base64url")}`;
+  }
+  async signedUrl(path, options) {
+    const token = createSignedStorageToken(path, options);
+    return `${(options.baseUrl || process.env.APP_URL || "http://localhost").replace(/\/$/, "")}/__storage/${encodeURIComponent(path)}?token=${token}`;
+  }
+  async checksum(path, options = {}) {
+    const algorithm = options.algorithm || "sha256", fullPath = this.resolvePath(path), bunFile = file(fullPath);
+    if (!await bunFile.exists())
+      throw Error(`File not found: ${path}`);
+    const hasher = new Bun.CryptoHasher(algorithm), arrayBuffer = await bunFile.arrayBuffer();
+    hasher.update(new Uint8Array(arrayBuffer));
+    return hasher.digest("hex");
+  }
+  async mimeType(path, _options = {}) {
+    const fullPath = this.resolvePath(path), bunFile = file(fullPath);
+    if (!await bunFile.exists())
+      throw Error(`File not found: ${path}`);
+    return bunFile.type || "application/octet-stream";
+  }
+  async lastModified(path) {
+    return (await this.stat(path)).lastModified;
+  }
+  async fileSize(path) {
+    return (await this.stat(path)).size;
+  }
+}
+export function createBunStorage(config = {}) {
+  return new BunStorageAdapter(config);
+}

package/dist/adapters/index.js

@@ -0,0 +1,5 @@
+export * from "./local";
+export * from "./memory";
+export * from "./s3";
+export * from "./bun";
+export * from "./scoped";

package/dist/adapters/local.js

@@ -0,0 +1,225 @@
+import { Buffer } from "node:buffer";
+import { createHmac } from "node:crypto";
+import { createReadStream, createWriteStream } from "node:fs";
+import { access, chmod, constants, copyFile, lstat, mkdir, readdir, readFile, rename, rm, stat, unlink, writeFile } from "node:fs/promises";
+import { basename, dirname, join, relative } from "node:path";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { createDirectoryListing, normalizeExpiryToDate } from "../types";
+import { createSignedStorageToken } from "../signed-url";
+
+export class LocalStorageAdapter {
+  root;
+  constructor(config = {}) {
+    this.root = config.root || process.cwd();
+  }
+  resolvePath(path) {
+    const resolved = join(this.root, path), rel = relative(this.root, resolved);
+    if (rel.startsWith("..") || rel.startsWith("../") || rel.startsWith("..\\"))
+      throw Error(`Path traversal detected: '${path}' resolves outside storage root`);
+    return resolved;
+  }
+  async write(path, contents) {
+    const fullPath = this.resolvePath(path), dir = dirname(fullPath);
+    await mkdir(dir, { recursive: !0 });
+    if (typeof contents === "string")
+      await writeFile(fullPath, contents, "utf8");
+    else if (contents instanceof Buffer)
+      await writeFile(fullPath, contents);
+    else if (contents instanceof Uint8Array)
+      await writeFile(fullPath, contents);
+    else {
+      const writeStream = createWriteStream(fullPath);
+      await pipeline(contents, writeStream);
+    }
+    const st = await stat(fullPath);
+    return {
+      path,
+      size: st.size,
+      lastModified: st.mtimeMs
+    };
+  }
+  async read(path) {
+    const fullPath = this.resolvePath(path);
+    return await readFile(fullPath);
+  }
+  async getStream(path, options) {
+    const fullPath = this.resolvePath(path);
+    await access(fullPath, constants.R_OK);
+    const nodeStream = createReadStream(fullPath, { signal: options?.signal });
+    return Readable.toWeb(nodeStream);
+  }
+  async putStream(path, stream, options) {
+    const fullPath = this.resolvePath(path), dir = dirname(fullPath);
+    await mkdir(dir, { recursive: !0 });
+    const nodeReadable = Readable.fromWeb(stream), writeStream = createWriteStream(fullPath);
+    try {
+      await pipeline(nodeReadable, writeStream, { signal: options?.signal });
+    } catch (err) {
+      try {
+        await unlink(fullPath);
+      } catch {}
+      throw err;
+    }
+    const st = await stat(fullPath);
+    return {
+      path,
+      size: st.size,
+      contentType: options?.contentType,
+      lastModified: st.mtimeMs
+    };
+  }
+  async readToString(path) {
+    const fullPath = this.resolvePath(path);
+    return await readFile(fullPath, "utf8");
+  }
+  async readToBuffer(path) {
+    const fullPath = this.resolvePath(path);
+    return await readFile(fullPath);
+  }
+  async readToUint8Array(path) {
+    const fullPath = this.resolvePath(path), buffer = await readFile(fullPath);
+    return new Uint8Array(buffer);
+  }
+  async deleteFile(path) {
+    const fullPath = this.resolvePath(path);
+    await unlink(fullPath);
+  }
+  async deleteDirectory(path) {
+    const fullPath = this.resolvePath(path);
+    await rm(fullPath, { recursive: !0, force: !0 });
+  }
+  async createDirectory(path) {
+    const fullPath = this.resolvePath(path);
+    await mkdir(fullPath, { recursive: !0 });
+  }
+  async moveFile(from, to) {
+    const fromPath = this.resolvePath(from), toPath = this.resolvePath(to), toDir = dirname(toPath);
+    await mkdir(toDir, { recursive: !0 });
+    await rename(fromPath, toPath);
+  }
+  async copyFile(from, to) {
+    const fromPath = this.resolvePath(from), toPath = this.resolvePath(to), toDir = dirname(toPath);
+    await mkdir(toDir, { recursive: !0 });
+    await copyFile(fromPath, toPath);
+  }
+  async stat(path) {
+    const fullPath = this.resolvePath(path), stats = await lstat(fullPath);
+    return {
+      path,
+      type: stats.isDirectory() ? "directory" : "file",
+      visibility: await this.visibility(path),
+      size: stats.size,
+      lastModified: stats.mtimeMs,
+      mimeType: stats.isFile() ? await this.detectMimeType(fullPath) : void 0
+    };
+  }
+  list(path, options = {}) {
+    return this.createAsyncIterator(path, options.deep || !1);
+  }
+  async* createAsyncIterator(path, deep) {
+    const fullPath = this.resolvePath(path);
+    try {
+      await access(fullPath, constants.R_OK);
+    } catch {
+      return;
+    }
+    const entries = await this.readDirectoryRecursive(fullPath, deep);
+    yield* createDirectoryListing(entries);
+  }
+  async readDirectoryRecursive(dirPath, deep) {
+    const entries = [];
+    try {
+      const items = await readdir(dirPath, { withFileTypes: !0 });
+      for (const item of items) {
+        const itemPath = join(dirPath, item.name), relativePath = relative(this.root, itemPath);
+        entries.push({
+          path: relativePath,
+          type: item.isDirectory() ? "directory" : "file"
+        });
+        if (deep && item.isDirectory()) {
+          const subEntries = await this.readDirectoryRecursive(itemPath, !0);
+          entries.push(...subEntries);
+        }
+      }
+    } catch (error) {
+      if (error?.code !== "EACCES" && error?.code !== "EPERM")
+        throw error;
+    }
+    return entries;
+  }
+  async changeVisibility(path, vis) {
+    const fullPath = this.resolvePath(path), isDir = (await lstat(fullPath)).isDirectory();
+    await chmod(fullPath, vis === "public" ? isDir ? 493 : 420 : isDir ? 448 : 384);
+  }
+  async visibility(path) {
+    const fullPath = this.resolvePath(path);
+    return (await lstat(fullPath)).mode & 511 & 4 ? "public" : "private";
+  }
+  async fileExists(path) {
+    const fullPath = this.resolvePath(path);
+    try {
+      return (await lstat(fullPath)).isFile();
+    } catch {
+      return !1;
+    }
+  }
+  async directoryExists(path) {
+    const fullPath = this.resolvePath(path);
+    try {
+      return (await lstat(fullPath)).isDirectory();
+    } catch {
+      return !1;
+    }
+  }
+  async publicUrl(path, options = {}) {
+    return `${(options.domain || process.env.APP_URL || "http://localhost").replace(/\/$/, "")}/${path}`;
+  }
+  async temporaryUrl(path, options) {
+    const expiry = normalizeExpiryToDate(options.expiresIn), payload = `${path}:${expiry.getTime()}`, appKey = process.env.APP_KEY || "stacks-default-key", signature = createHmac("sha256", appKey).update(payload).digest("hex");
+    return `http://localhost/temp/${Buffer.from(`${payload}:${signature}`).toString("base64url")}`;
+  }
+  async signedUrl(path, options) {
+    const token = createSignedStorageToken(path, options);
+    return `${(options.baseUrl || process.env.APP_URL || "http://localhost").replace(/\/$/, "")}/__storage/${encodeURIComponent(path)}?token=${token}`;
+  }
+  async checksum(path, options = {}) {
+    const algorithm = options.algorithm || "sha256", fullPath = this.resolvePath(path), content = await readFile(fullPath), hasher = new Bun.CryptoHasher(algorithm);
+    hasher.update(content);
+    return hasher.digest("hex");
+  }
+  async mimeType(path, options = {}) {
+    const fullPath = this.resolvePath(path);
+    return await this.detectMimeType(fullPath);
+  }
+  async detectMimeType(filePath) {
+    const ext = basename(filePath).split(".").pop()?.toLowerCase();
+    return {
+      txt: "text/plain",
+      html: "text/html",
+      css: "text/css",
+      js: "application/javascript",
+      json: "application/json",
+      xml: "application/xml",
+      pdf: "application/pdf",
+      zip: "application/zip",
+      jpg: "image/jpeg",
+      jpeg: "image/jpeg",
+      png: "image/png",
+      gif: "image/gif",
+      svg: "image/svg+xml",
+      mp4: "video/mp4",
+      mp3: "audio/mpeg",
+      wav: "audio/wav"
+    }[ext || ""] || "application/octet-stream";
+  }
+  async lastModified(path) {
+    return (await this.stat(path)).lastModified;
+  }
+  async fileSize(path) {
+    return (await this.stat(path)).size;
+  }
+}
+export function createLocalStorage(config = {}) {
+  return new LocalStorageAdapter(config);
+}