@stacksjs/storage 0.70.88 → 0.70.90

package/dist/adapters/memory.js

@@ -0,0 +1,318 @@
+import { Buffer } from "node:buffer";
+import { basename } from "node:path";
+import { createDirectoryListing, normalizeExpiryToDate } from "../types";
+
+export class InMemoryStorageAdapter {
+  files;
+  directories;
+  constructor() {
+    this.files = new Map;
+    this.directories = new Set;
+    this.directories.add("");
+  }
+  normalizePath(path) {
+    return path.replace(/^\/+/, "").replace(/\/+$/, "");
+  }
+  getDirectoryPath(path) {
+    const parts = path.split("/").filter(Boolean);
+    parts.pop();
+    return parts.join("/");
+  }
+  async contentsToUint8Array(contents) {
+    if (typeof contents === "string")
+      return new TextEncoder().encode(contents);
+    else if (contents instanceof Buffer)
+      return new Uint8Array(contents);
+    else if (contents instanceof Uint8Array)
+      return contents;
+    else {
+      if (typeof contents.getReader !== "function")
+        throw TypeError("[storage/memory] 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;
+      }
+      return result;
+    }
+  }
+  async write(path, contents) {
+    const normalized = this.normalizePath(path), dirPath = this.getDirectoryPath(normalized);
+    if (dirPath)
+      await this.createDirectory(dirPath);
+    const data = await this.contentsToUint8Array(contents), lastModified = Date.now(), mimeType = this.detectMimeType(normalized);
+    this.files.set(normalized, {
+      contents: data,
+      visibility: "private",
+      mimeType,
+      lastModified
+    });
+    return {
+      path: normalized,
+      size: data.length,
+      contentType: mimeType,
+      lastModified
+    };
+  }
+  async read(path) {
+    const normalized = this.normalizePath(path), file = this.files.get(normalized);
+    if (!file)
+      throw Error(`File not found: ${path}`);
+    return file.contents;
+  }
+  async getStream(path, _options) {
+    const normalized = this.normalizePath(path), file = this.files.get(normalized);
+    if (!file)
+      throw Error(`File not found: ${path}`);
+    const bytes = file.contents;
+    return new ReadableStream({
+      start(controller) {
+        controller.enqueue(bytes);
+        controller.close();
+      }
+    });
+  }
+  async putStream(path, stream, options) {
+    const normalized = this.normalizePath(path), dirPath = this.getDirectoryPath(normalized);
+    if (dirPath)
+      await this.createDirectory(dirPath);
+    const chunks = [], reader = stream.getReader(), abort = options?.signal;
+    try {
+      while (!0) {
+        if (abort?.aborted)
+          throw Error("aborted");
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        if (value)
+          chunks.push(value);
+      }
+    } finally {
+      try {
+        reader.releaseLock();
+      } catch {}
+    }
+    const totalLength = chunks.reduce((sum, c) => sum + c.length, 0), data = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const c of chunks) {
+      data.set(c, offset);
+      offset += c.length;
+    }
+    const lastModified = Date.now(), mimeType = options?.contentType ?? this.detectMimeType(normalized);
+    this.files.set(normalized, {
+      contents: data,
+      visibility: "private",
+      mimeType,
+      lastModified
+    });
+    return { path: normalized, size: data.length, contentType: mimeType, lastModified };
+  }
+  async readToString(path) {
+    const data = await this.read(path);
+    return new TextDecoder().decode(data);
+  }
+  async readToBuffer(path) {
+    const data = await this.read(path);
+    return Buffer.from(data);
+  }
+  async readToUint8Array(path) {
+    return await this.read(path);
+  }
+  async deleteFile(path) {
+    const normalized = this.normalizePath(path);
+    if (!this.files.has(normalized))
+      throw Error(`File not found: ${path}`);
+    this.files.delete(normalized);
+  }
+  async deleteDirectory(path) {
+    const normalized = this.normalizePath(path), prefix = normalized ? `${normalized}/` : "";
+    for (const filePath of this.files.keys())
+      if (filePath === normalized || filePath.startsWith(prefix))
+        this.files.delete(filePath);
+    for (const dir of this.directories)
+      if (dir === normalized || dir.startsWith(prefix))
+        this.directories.delete(dir);
+  }
+  async createDirectory(path) {
+    const normalized = this.normalizePath(path);
+    if (!normalized)
+      return;
+    const parts = normalized.split("/").filter(Boolean);
+    let current = "";
+    for (const part of parts) {
+      current = current ? `${current}/${part}` : part;
+      this.directories.add(current);
+    }
+  }
+  async moveFile(from, to) {
+    const normalizedFrom = this.normalizePath(from), normalizedTo = this.normalizePath(to), file = this.files.get(normalizedFrom);
+    if (!file)
+      throw Error(`File not found: ${from}`);
+    const toDir = this.getDirectoryPath(normalizedTo);
+    if (toDir)
+      await this.createDirectory(toDir);
+    this.files.set(normalizedTo, { ...file, lastModified: Date.now() });
+    this.files.delete(normalizedFrom);
+  }
+  async copyFile(from, to) {
+    const normalizedFrom = this.normalizePath(from), normalizedTo = this.normalizePath(to), file = this.files.get(normalizedFrom);
+    if (!file)
+      throw Error(`File not found: ${from}`);
+    const toDir = this.getDirectoryPath(normalizedTo);
+    if (toDir)
+      await this.createDirectory(toDir);
+    const contentsCopy = new Uint8Array(file.contents);
+    this.files.set(normalizedTo, {
+      ...file,
+      contents: contentsCopy,
+      lastModified: Date.now()
+    });
+  }
+  async stat(path) {
+    const normalized = this.normalizePath(path), file = this.files.get(normalized);
+    if (file)
+      return {
+        path: normalized,
+        type: "file",
+        visibility: file.visibility,
+        size: file.contents.length,
+        lastModified: file.lastModified,
+        mimeType: file.mimeType
+      };
+    if (this.directories.has(normalized) || normalized === "")
+      return {
+        path: normalized,
+        type: "directory",
+        visibility: "private",
+        size: 0,
+        lastModified: Date.now()
+      };
+    throw Error(`Path not found: ${path}`);
+  }
+  list(path, options = {}) {
+    return this.createAsyncIterator(path, options.deep || !1);
+  }
+  async* createAsyncIterator(path, deep) {
+    const normalized = this.normalizePath(path), prefix = normalized ? `${normalized}/` : "", entries = [], seen = new Set;
+    for (const [filePath] of this.files)
+      if (filePath.startsWith(prefix) || prefix === "") {
+        const relativePath = prefix ? filePath.slice(prefix.length) : filePath;
+        if (!deep) {
+          if (relativePath.split("/").filter(Boolean).length === 1)
+            entries.push({
+              path: filePath,
+              type: "file"
+            });
+        } else
+          entries.push({
+            path: filePath,
+            type: "file"
+          });
+      }
+    for (const dir of this.directories)
+      if ((dir.startsWith(prefix) || prefix === "") && dir !== normalized) {
+        const relativePath = prefix ? dir.slice(prefix.length) : dir;
+        if (!deep) {
+          if (relativePath.split("/").filter(Boolean).length === 1 && !seen.has(dir)) {
+            entries.push({
+              path: dir,
+              type: "directory"
+            });
+            seen.add(dir);
+          }
+        } else if (!seen.has(dir)) {
+          entries.push({
+            path: dir,
+            type: "directory"
+          });
+          seen.add(dir);
+        }
+      }
+    yield* createDirectoryListing(entries);
+  }
+  async changeVisibility(path, visibility) {
+    const normalized = this.normalizePath(path), file = this.files.get(normalized);
+    if (!file)
+      throw Error(`File not found: ${path}`);
+    file.visibility = visibility;
+  }
+  async visibility(path) {
+    const normalized = this.normalizePath(path), file = this.files.get(normalized);
+    if (!file)
+      throw Error(`File not found: ${path}`);
+    return file.visibility;
+  }
+  async fileExists(path) {
+    const normalized = this.normalizePath(path);
+    return this.files.has(normalized);
+  }
+  async directoryExists(path) {
+    const normalized = this.normalizePath(path);
+    return this.directories.has(normalized) || normalized === "";
+  }
+  async publicUrl(path, options = {}) {
+    return `${(options.domain || process.env.APP_URL || "http://localhost").replace(/\/$/, "")}/${this.normalizePath(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) {
+    throw Error("[storage/memory] signedUrl is not supported on the in-memory adapter \u2014 switch to local or s3 disk for signed URL generation.");
+  }
+  async checksum(path, options = {}) {
+    const algorithm = options.algorithm || "sha256", data = await this.readToUint8Array(path), hasher = new Bun.CryptoHasher(algorithm);
+    hasher.update(data);
+    return hasher.digest("hex");
+  }
+  async mimeType(path, _options = {}) {
+    const normalized = this.normalizePath(path), file = this.files.get(normalized);
+    if (!file)
+      throw Error(`File not found: ${path}`);
+    return file.mimeType;
+  }
+  detectMimeType(path) {
+    const ext = basename(path).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;
+  }
+  clear() {
+    this.files.clear();
+    this.directories.clear();
+    this.directories.add("");
+  }
+}
+export function createMemoryStorage() {
+  return new InMemoryStorageAdapter;
+}

package/dist/adapters/s3.d.ts

@@ -0,0 +1,53 @@
+import { Buffer } from 'node:buffer';
+import type { ChecksumOptions, DirectoryListing, FileContents, GetStreamOptions, ListOptions, MimeTypeOptions, PresignedUploadPolicy, PresignedUploadPolicyOptions, PresignedUploadUrl, PresignedUploadUrlOptions, PublicUrlOptions, PutResult, PutStreamOptions, SignedUrlOptions, StatEntry, StorageAdapter, StorageAdapterConfig, TemporaryUrlOptions, Visibility } from '../types';
+import type { S3Client } from '@stacksjs/ts-cloud';
+/**
+ * Create an S3 storage adapter instance
+ */
+export declare function createS3Storage(client: S3Client | null, config: StorageAdapterConfig): S3StorageAdapter;
+/**
+ * Append-and-take byte buffer used by the multipart pipeline
+ * (stacksjs/stacks#1886). Holds incoming chunks until they reach
+ * the configured part size, then yields them as a single Uint8Array
+ * via `take(n)` or `flush()`.
+ */
+declare class ChunkBuffer {
+  constructor(_partSize: number);
+  get length(): number;
+  push(c: Uint8Array): void;
+  take(n: number): Uint8Array;
+  flush(): Uint8Array;
+}
+/**
+ * AWS S3 storage adapter using ts-cloud S3Client
+ */
+export declare class S3StorageAdapter implements StorageAdapter {
+  constructor(client: S3Client | null, config: StorageAdapterConfig);
+  write(path: string, contents: FileContents): Promise<PutResult>;
+  read(path: string): Promise<FileContents>;
+  getStream(path: string, _options?: GetStreamOptions): Promise<ReadableStream<Uint8Array>>;
+  putStream(path: string, stream: ReadableStream<Uint8Array>, options?: PutStreamOptions): Promise<PutResult>;
+  readToString(path: string): Promise<string>;
+  readToBuffer(path: string): Promise<Buffer>;
+  readToUint8Array(path: string): Promise<Uint8Array>;
+  deleteFile(path: string): Promise<void>;
+  deleteDirectory(path: string): Promise<void>;
+  createDirectory(_path: string): Promise<void>;
+  moveFile(from: string, to: string): Promise<void>;
+  copyFile(from: string, to: string): Promise<void>;
+  stat(path: string): Promise<StatEntry>;
+  list(path: string, options?: ListOptions): DirectoryListing;
+  changeVisibility(path: string, vis: Visibility): Promise<void>;
+  visibility(path: string): Promise<Visibility>;
+  fileExists(path: string): Promise<boolean>;
+  directoryExists(path: string): Promise<boolean>;
+  publicUrl(path: string, options?: PublicUrlOptions): Promise<string>;
+  temporaryUrl(path: string, options: TemporaryUrlOptions): Promise<string>;
+  signedUrl(path: string, options: SignedUrlOptions): Promise<string>;
+  presignedUploadUrl(options: PresignedUploadUrlOptions): Promise<PresignedUploadUrl>;
+  presignedUploadPolicy(options: PresignedUploadPolicyOptions): Promise<PresignedUploadPolicy>;
+  checksum(path: string, options?: ChecksumOptions): Promise<string>;
+  mimeType(path: string, _options?: MimeTypeOptions): Promise<string>;
+  lastModified(path: string): Promise<number>;
+  fileSize(path: string): Promise<number>;
+}