Storage

FILESYSTEM_STORAGE_PATH=./storage
STORAGE_CLOUDFLARE_ACCESS_KEY=your_access_key
STORAGE_CLOUDFLARE_SECRET_KEY=your_secret_key
STORAGE_CLOUDFLARE_ENDPOINT=https://your-account.r2.cloudflarestorage.com
STORAGE_BUNNY_ACCESS_KEY=your_access_key
STORAGE_BUNNY_STORAGE_ZONE=your-zone

import { CloudflareStorage } from "@ooneex/storage";
import { container } from "@ooneex/container";

const storage = container.get(CloudflareStorage).setBucket("uploads");

// Write content — returns the number of bytes written
await storage.put("avatars/123.png", file); // file: Blob | BunFile | ArrayBuffer | ...
await storage.put("config.json", JSON.stringify({ theme: "dark" }));

// Read it back
const config = await storage.getAsJson<{ theme: string }>("config.json");
const buffer = await storage.getAsArrayBuffer("avatars/123.png");

// Existence, listing, and removal
await storage.exists("avatars/123.png"); // true
const keys = await storage.list();
await storage.delete("avatars/123.png");

// Upload one local file
await storage.putFile("avatars/123.png", "/tmp/avatar.png");

// Upload a directory recursively, keeping only images
await storage.putDir("avatars", {
  path: "/tmp/avatars",
  filter: /\.(png|jpe?g)$/,
});

// Download an object to a local directory
await storage.getFile("avatars/123.png", {
  outputDir: "/tmp/downloads",
  filename: "user-avatar.png",
});

const stream = storage.getAsStream("videos/intro.mp4");
return new Response(stream);

import { decorator } from "@ooneex/storage";
import { CloudflareStorage } from "@ooneex/storage";

@decorator.storage()
export class UploadStorage extends CloudflareStorage {}

import { inject } from "@ooneex/container";

export class UploadService {
  constructor(@inject(UploadStorage) private readonly storage: UploadStorage) {}
}

import { StorageException } from "@ooneex/storage";

try {
  await storage.put("avatars/123.png", file);
} catch (error) {
  if (error instanceof StorageException) {
    logger.error(`Storage error [${error.key}]: ${error.message}`, error.data);
  } else {
    throw error;
  }
}

# Interactive: prompts for the name
ooneex storage:create

# Provide the name
ooneex storage:create --name=Upload

# Target a module and overwrite
ooneex storage:create --name=Upload --module=media --override

import { Storage, decorator, StorageException } from "@ooneex/storage";
import { inject } from "@ooneex/container";
import { AppEnv } from "@ooneex/app-env";
import type { S3Options } from "bun";

@decorator.storage()
export class UploadStorage extends Storage {
  protected bucket: string;
  private readonly accessKey: string;
  private readonly secretKey: string;
  private readonly endpoint: string;
  private readonly region: string;

  constructor(
    @inject(AppEnv) private readonly env: AppEnv,
    options?: {
      accessKey?: string;
      secretKey?: string;
      endpoint?: string;
      region?: string;
    },
  ) {
    super();

    const accessKey = options?.accessKey || this.env.STORAGE_UPLOAD_ACCESS_KEY;
    const secretKey = options?.secretKey || this.env.STORAGE_UPLOAD_SECRET_KEY;
    const endpoint = options?.endpoint || this.env.STORAGE_UPLOAD_ENDPOINT;

    if (!accessKey) {
      throw new StorageException(
        "Upload access key is required. Please provide an access key either through the constructor options or set the STORAGE_UPLOAD_ACCESS_KEY environment variable.",
      );
    }
    if (!secretKey) {
      throw new StorageException(
        "Upload secret key is required. Please provide a secret key either through the constructor options or set the STORAGE_UPLOAD_SECRET_KEY environment variable.",
      );
    }
    if (!endpoint) {
      throw new StorageException(
        "Upload endpoint is required. Please provide an endpoint either through the constructor options or set the STORAGE_UPLOAD_ENDPOINT environment variable.",
      );
    }

    this.accessKey = accessKey;
    this.secretKey = secretKey;
    this.endpoint = endpoint;
    this.region = options?.region || this.env.STORAGE_UPLOAD_REGION || "auto";
  }

  public getOptions(): S3Options {
    return {
      accessKeyId: this.accessKey,
      secretAccessKey: this.secretKey,
      endpoint: this.endpoint,
      bucket: this.bucket,
      region: this.region,
    };
  }
}