opacacms 0.1.0

package/src/storage/adapters/local.ts

@@ -0,0 +1,146 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { FileTooLargeError, Invalidmime_typeError, StorageError } from "../errors";
+import type {
+  FileData,
+  FileRecord,
+  StorageAdapter,
+  StorageAdapterConfig,
+  UploadOptions,
+} from "../types";
+
+export interface LocalAdapterConfig extends StorageAdapterConfig {
+  uploadDir: string;
+  publicUrl: string;
+}
+
+export function createLocalAdapter(config: LocalAdapterConfig): StorageAdapter {
+  fs.mkdir(config.uploadDir, { recursive: true }).catch((err) => {
+    console.error(
+      `[OpacaCMS:LocalAdapter] Failed to create upload directory ${config.uploadDir}:`,
+      err,
+    );
+  });
+
+  const getFullPath = (filename: string) => {
+    return path.join(config.uploadDir, filename);
+  };
+
+  const getPublicUrl = (filename: string) => {
+    const base = config.publicUrl.replace(/\/$/, "");
+    return `${base}/${filename}`;
+  };
+
+  return {
+    name: "local",
+
+    async upload(file: FileRecord, options?: UploadOptions): Promise<FileData> {
+      try {
+        if (options?.allowedmime_types && !options.allowedmime_types.includes(file.mime_type)) {
+          throw new Invalidmime_typeError("local", options.allowedmime_types, file.mime_type);
+        }
+
+        if (options?.maxFileSize && file.filesize > options.maxFileSize) {
+          throw new FileTooLargeError("local", options.maxFileSize, file.filesize);
+        }
+
+        let finalFilename = file.filename;
+        if (options?.generateUniqueName) {
+          const ext = path.extname(file.original_filename);
+          const hash = crypto.randomUUID().split("-")[0];
+          const base = path
+            .basename(finalFilename, ext)
+            .replace(/[^a-z0-9]/gi, "-")
+            .toLowerCase();
+          finalFilename = `${base}-${hash}${ext}`;
+        }
+
+        // Sanitization against path traversal
+        const sanitizedFilename = path.basename(finalFilename);
+        const fullPath = path.resolve(config.uploadDir, sanitizedFilename);
+
+        if (!fullPath.startsWith(path.resolve(config.uploadDir))) {
+          throw new StorageError("local", "upload", "Path traversal attempt detected.");
+        }
+
+        if (file.buffer && typeof Bun !== "undefined") {
+          await Bun.write(fullPath, file.buffer);
+        } else if (file.buffer) {
+          await fs.writeFile(fullPath, file.buffer);
+        } else if (file.stream) {
+          const writeStream = require("node:fs").createWriteStream(fullPath);
+          const reader = file.stream.getReader();
+
+          try {
+            while (true) {
+              const { done, value } = await reader.read();
+              if (done) break;
+              if (value) {
+                writeStream.write(Buffer.from(value));
+              }
+            }
+          } finally {
+            writeStream.end();
+            reader.releaseLock();
+          }
+        } else {
+          throw new Error("Neither Buffer nor Stream provided.");
+        }
+
+        return {
+          filename: sanitizedFilename,
+          mime_type: file.mime_type,
+          filesize: file.filesize,
+          url: getPublicUrl(sanitizedFilename),
+        };
+      } catch (error) {
+        if (error instanceof StorageError) throw error;
+        throw new StorageError(
+          "local",
+          "upload",
+          `Failed to write ${file.filename} to disk`,
+          error,
+        );
+      }
+    },
+
+    async delete(filename: string): Promise<void> {
+      try {
+        const fullPath = getFullPath(path.basename(filename));
+        await fs.unlink(fullPath);
+      } catch (error: any) {
+        if (error.code !== "ENOENT") {
+          throw new StorageError("local", "delete", `Failed to delete ${filename}`, error);
+        }
+      }
+    },
+
+    async exists(filename: string): Promise<boolean> {
+      try {
+        await fs.access(getFullPath(path.basename(filename)), require("node:fs").constants.F_OK);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+
+    async download(filename: string): Promise<ReadableStream<Uint8Array>> {
+      const fullPath = getFullPath(path.basename(filename));
+      if (typeof Bun !== "undefined") {
+        return Bun.file(fullPath).stream();
+      }
+
+      const nodeStream = require("node:fs").createReadStream(fullPath);
+      return new ReadableStream({
+        start(controller) {
+          nodeStream.on("data", (chunk: Buffer) => controller.enqueue(new Uint8Array(chunk)));
+          nodeStream.on("end", () => controller.close());
+          nodeStream.on("error", (err: Error) => controller.error(err));
+        },
+        cancel() {
+          nodeStream.destroy();
+        },
+      });
+    },
+  };
+}

package/src/storage/adapters/s3.ts

@@ -0,0 +1,186 @@
+import {
+  DeleteObjectCommand,
+  GetObjectCommand,
+  HeadObjectCommand,
+  PutObjectCommand,
+  S3Client,
+} from "@aws-sdk/client-s3";
+import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+import { FileTooLargeError, Invalidmime_typeError, StorageError } from "../errors";
+import type {
+  FileData,
+  FileRecord,
+  StorageAdapter,
+  StorageAdapterConfig,
+  UploadOptions,
+} from "../types";
+
+export interface S3AdapterConfig extends StorageAdapterConfig {
+  region: string;
+  bucket: string;
+  endpoint?: string;
+  credentials?: {
+    accessKeyId: string;
+    secretAccessKey: string;
+  };
+  forcePathStyle?: boolean;
+  acl?: "private" | "public-read";
+}
+
+export function createS3Adapter(config: S3AdapterConfig): StorageAdapter {
+  const s3Client = new S3Client({
+    region: config.region,
+    endpoint: config.endpoint,
+    credentials: config.credentials,
+    forcePathStyle: config.forcePathStyle,
+  });
+
+  const getFullKey = (filename: string) => {
+    if (config.prefix) {
+      const p = config.prefix.replace(/\/$/, "");
+      return `${p}/${filename}`;
+    }
+    return filename;
+  };
+
+  const getPublicUrl = (filename: string) => {
+    if (config.publicUrl) {
+      const base = config.publicUrl.replace(/\/$/, "");
+      return `${base}/${getFullKey(filename)}`;
+    }
+    return `https://${config.bucket}.s3.${config.region}.amazonaws.com/${getFullKey(filename)}`;
+  };
+
+  return {
+    name: "s3",
+    async upload(file: FileRecord, options?: UploadOptions): Promise<FileData> {
+      try {
+        if (options?.allowedmime_types && !options.allowedmime_types.includes(file.mime_type)) {
+          throw new Invalidmime_typeError("s3", options.allowedmime_types, file.mime_type);
+        }
+
+        if (options?.maxFileSize && file.filesize > options.maxFileSize) {
+          throw new FileTooLargeError("s3", options.maxFileSize, file.filesize);
+        }
+
+        let finalFilename = file.filename;
+        if (options?.generateUniqueName) {
+          const ext = file.original_filename.split(".").pop() || "";
+          const hash = crypto.randomUUID().split("-")[0];
+          const base = finalFilename
+            .replace(`.${ext}`, "")
+            .replace(/[^a-z0-9]/gi, "-")
+            .toLowerCase();
+          finalFilename = `${base}-${hash}.${ext}`;
+        }
+
+        const key = getFullKey(finalFilename);
+
+        const body = file.buffer || file.stream;
+
+        const command = new PutObjectCommand({
+          Bucket: config.bucket,
+          Key: key,
+          Body: body as any, // Stream/Buffer compatibility
+          ContentType: file.mime_type,
+          ContentLength: file.filesize,
+          ACL: config.acl || "private",
+        });
+
+        await s3Client.send(command);
+
+        return {
+          filename: finalFilename,
+          mime_type: file.mime_type,
+          filesize: file.filesize,
+          url: getPublicUrl(finalFilename),
+        };
+      } catch (error) {
+        if (error instanceof StorageError) throw error;
+        throw new StorageError(
+          "s3",
+          "upload",
+          `Failed to upload ${file.filename} to S3 bucket ${config.bucket}`,
+          error,
+        );
+      }
+    },
+
+    async delete(filename: string): Promise<void> {
+      try {
+        const command = new DeleteObjectCommand({
+          Bucket: config.bucket,
+          Key: getFullKey(filename),
+        });
+        await s3Client.send(command);
+      } catch (error) {
+        throw new StorageError(
+          "s3",
+          "delete",
+          `Failed to delete ${filename} from S3 bucket ${config.bucket}`,
+          error,
+        );
+      }
+    },
+
+    async exists(filename: string): Promise<boolean> {
+      try {
+        const command = new HeadObjectCommand({
+          Bucket: config.bucket,
+          Key: getFullKey(filename),
+        });
+        await s3Client.send(command);
+        return true;
+      } catch (error: any) {
+        if (error.name === "NotFound" || error.$metadata?.httpStatusCode === 404) return false;
+        throw new StorageError("s3", "download", `Failed to check existence of ${filename}`, error);
+      }
+    },
+
+    async generatePresignedUrl(
+      filename: string,
+      operation: "read" | "write",
+      expiresInSeconds = 3600,
+    ): Promise<string> {
+      try {
+        let command;
+        if (operation === "write") {
+          command = new PutObjectCommand({ Bucket: config.bucket, Key: getFullKey(filename) });
+        } else {
+          command = new GetObjectCommand({ Bucket: config.bucket, Key: getFullKey(filename) });
+        }
+
+        return await getSignedUrl(s3Client, command, { expiresIn: expiresInSeconds });
+      } catch (error) {
+        throw new StorageError(
+          "s3",
+          "presign",
+          `Failed to generate presigned URL for ${filename}`,
+          error,
+        );
+      }
+    },
+
+    async download(filename: string): Promise<ReadableStream<Uint8Array>> {
+      try {
+        const command = new GetObjectCommand({
+          Bucket: config.bucket,
+          Key: getFullKey(filename),
+        });
+        const response = await s3Client.send(command);
+        if (!response.Body) {
+          throw new StorageError("s3", "download", `File not found: ${filename}`);
+        }
+        return response.Body.transformToWebStream() as ReadableStream<Uint8Array>;
+      } catch (error) {
+        if (error instanceof StorageError) throw error;
+        throw new StorageError(
+          "s3",
+          "download",
+          `Failed to download ${filename} from S3 bucket ${config.bucket}`,
+          error,
+        );
+      }
+    },
+  };
+}

package/src/storage/errors.ts

@@ -0,0 +1,46 @@
+export class StorageError extends Error {
+  public provider: string;
+  public operation: "upload" | "delete" | "download" | "presign" | "exists";
+  public originalError: unknown;
+
+  constructor(
+    provider: string,
+    operation: "upload" | "delete" | "download" | "presign" | "exists",
+    message: string,
+    originalError?: unknown,
+  ) {
+    const originalMessage =
+      originalError instanceof Error
+        ? `: ${originalError.message}`
+        : originalError
+          ? `: ${String(originalError)}`
+          : "";
+    super(`[OpacaStorage::${provider}] Failed to ${operation}: ${message}${originalMessage}`);
+    this.name = "StorageError";
+    this.provider = provider;
+    this.operation = operation;
+    this.originalError = originalError;
+  }
+}
+
+export class FileTooLargeError extends StorageError {
+  constructor(provider: string, maxBytes: number, actualBytes: number) {
+    super(
+      provider,
+      "upload",
+      `File size (${actualBytes} bytes) exceeds the maximum allowed (${maxBytes} bytes).`,
+    );
+    this.name = "FileTooLargeError";
+  }
+}
+
+export class Invalidmime_typeError extends StorageError {
+  constructor(provider: string, allowedTypes: string[], actualType: string) {
+    super(
+      provider,
+      "upload",
+      `MIME type '${actualType}' is not allowed. Expected one of: ${allowedTypes.join(", ")}.`,
+    );
+    this.name = "Invalidmime_typeError";
+  }
+}

package/src/storage/index.ts

@@ -0,0 +1,5 @@
+export * from "./adapters/cloudflare-r2";
+export * from "./adapters/local";
+export * from "./adapters/s3";
+export * from "./errors";
+export * from "./types";

package/src/storage/types.ts

@@ -0,0 +1,39 @@
+export interface StorageAdapterConfig {
+  prefix?: string;
+  publicUrl?: string;
+}
+
+export interface FileRecord {
+  filename: string;
+  original_filename: string;
+  mime_type: string;
+  filesize: number;
+  buffer?: Uint8Array;
+  stream?: ReadableStream<Uint8Array>;
+}
+
+export interface UploadOptions {
+  allowedmime_types?: string[];
+  maxFileSize?: number;
+  generateUniqueName?: boolean;
+}
+
+export interface FileData {
+  filename: string;
+  url: string;
+  filesize: number;
+  mime_type: string;
+}
+
+export interface StorageAdapter {
+  name: string;
+  upload(file: FileRecord, options?: UploadOptions): Promise<FileData>;
+  delete(filename: string): Promise<void>;
+  exists?(filename: string): Promise<boolean>;
+  download?(filename: string): Promise<ReadableStream<Uint8Array>>;
+  generatePresignedUrl?(
+    filename: string,
+    operation: "read" | "write",
+    expiresInSeconds?: number,
+  ): Promise<string>;
+}