opacacms 0.1.1 → 0.1.2

package/src/storage/adapters/local.ts

@@ -1,146 +0,0 @@
-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

@@ -1,186 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1,6 +0,0 @@
-// Only export types and errors — concrete adapters are in their own subpaths:
-// opacacms/storage/s3    → S3 / Cloudflare R2
-// opacacms/storage/r2    → Cloudflare R2
-// opacacms/storage/local → Local filesystem
-export * from "./errors";
-export * from "./types";

package/src/storage/types.ts

@@ -1,39 +0,0 @@
-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>;
-}