opacacms 0.1.0

package/dist/src/server.js

@@ -0,0 +1,27 @@
+import {
+  createAPIRouter,
+  createAdminHandlers,
+  createGlobalHandlers,
+  createHandlers,
+  hydrateDoc
+} from "../chunk-hmhcense.js";
+import {
+  defineConfig
+} from "../chunk-zvwb67nd.js";
+import"../chunk-dy5t83hr.js";
+import {
+  BaseDatabaseAdapter
+} from "../chunk-s8mqwnm1.js";
+import"../chunk-62ev8gnc.js";
+import"../chunk-cvdd4eqh.js";
+import"../chunk-ybbbqj63.js";
+import"../chunk-8sqjbsgt.js";
+export {
+  hydrateDoc,
+  defineConfig,
+  createHandlers,
+  createGlobalHandlers,
+  createAdminHandlers,
+  createAPIRouter,
+  BaseDatabaseAdapter
+};

package/dist/src/storage/index.js

@@ -0,0 +1,355 @@
+import {
+  __require
+} from "../../chunk-8sqjbsgt.js";
+
+// src/storage/errors.ts
+class StorageError extends Error {
+  provider;
+  operation;
+  originalError;
+  constructor(provider, operation, message, originalError) {
+    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;
+  }
+}
+
+class FileTooLargeError extends StorageError {
+  constructor(provider, maxBytes, actualBytes) {
+    super(provider, "upload", `File size (${actualBytes} bytes) exceeds the maximum allowed (${maxBytes} bytes).`);
+    this.name = "FileTooLargeError";
+  }
+}
+
+class Invalidmime_typeError extends StorageError {
+  constructor(provider, allowedTypes, actualType) {
+    super(provider, "upload", `MIME type '${actualType}' is not allowed. Expected one of: ${allowedTypes.join(", ")}.`);
+    this.name = "Invalidmime_typeError";
+  }
+}
+
+// src/storage/adapters/cloudflare-r2.ts
+function createR2Storage(config) {
+  const getFullKey = (filename) => {
+    return config.prefix ? `${config.prefix.replace(/\/$/, "")}/${filename}` : filename;
+  };
+  const getPublicUrl = (filename) => {
+    if (!config.publicUrl) {
+      throw new Error("Cloudflare R2 requires a 'publicUrl' (custom domain) configured in the adapter to return accessible URLs.");
+    }
+    return `${config.publicUrl.replace(/\/$/, "")}/${getFullKey(filename)}`;
+  };
+  return {
+    name: "cloudflare-r2",
+    async upload(file, options) {
+      try {
+        if (options?.allowedmime_types && !options.allowedmime_types.includes(file.mime_type)) {
+          throw new Invalidmime_typeError("cloudflare-r2", options.allowedmime_types, file.mime_type);
+        }
+        if (options?.maxFileSize && file.filesize > options.maxFileSize) {
+          throw new FileTooLargeError("cloudflare-r2", options.maxFileSize, file.filesize);
+        }
+        let finalFilename = file.filename;
+        if (options?.generateUniqueName) {
+          const ext = file.original_filename.split(".").pop() || "";
+          const hash = crypto.randomUUID().split("-")[0];
+          finalFilename = `${finalFilename.replace(`.${ext}`, "")}-${hash}.${ext}`;
+        }
+        const key = getFullKey(finalFilename);
+        const body = file.buffer || file.stream;
+        if (!body) {
+          throw new StorageError("cloudflare-r2", "upload", `No content provided for file ${file.filename}`);
+        }
+        await config.bucketBinding.put(key, body, {
+          httpMetadata: {
+            contentType: file.mime_type
+          }
+        });
+        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("cloudflare-r2", "upload", `Failed to upload ${file.filename} to R2 bucket`, error);
+      }
+    },
+    async delete(filename) {
+      try {
+        await config.bucketBinding.delete(getFullKey(filename));
+      } catch (error) {
+        throw new StorageError("cloudflare-r2", "delete", `Failed to delete ${filename} from R2 bucket`, error);
+      }
+    },
+    async exists(filename) {
+      try {
+        const head = await config.bucketBinding.head(getFullKey(filename));
+        return head !== null;
+      } catch (error) {
+        throw new StorageError("cloudflare-r2", "exists", `Failed to check existence of ${filename} in R2 bucket`, error);
+      }
+    },
+    async download(filename) {
+      try {
+        const object = await config.bucketBinding.get(getFullKey(filename));
+        if (!object) {
+          throw new StorageError("cloudflare-r2", "download", `File not found: ${filename}`);
+        }
+        return object.body;
+      } catch (error) {
+        if (error instanceof StorageError)
+          throw error;
+        throw new StorageError("cloudflare-r2", "download", `Failed to download ${filename} from R2 bucket`, error);
+      }
+    }
+  };
+}
+// src/storage/adapters/local.ts
+import fs from "node:fs/promises";
+import path from "node:path";
+function createLocalAdapter(config) {
+  fs.mkdir(config.uploadDir, { recursive: true }).catch((err) => {
+    console.error(`[OpacaCMS:LocalAdapter] Failed to create upload directory ${config.uploadDir}:`, err);
+  });
+  const getFullPath = (filename) => {
+    return path.join(config.uploadDir, filename);
+  };
+  const getPublicUrl = (filename) => {
+    const base = config.publicUrl.replace(/\/$/, "");
+    return `${base}/${filename}`;
+  };
+  return {
+    name: "local",
+    async upload(file, options) {
+      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}`;
+        }
+        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) {
+      try {
+        const fullPath = getFullPath(path.basename(filename));
+        await fs.unlink(fullPath);
+      } catch (error) {
+        if (error.code !== "ENOENT") {
+          throw new StorageError("local", "delete", `Failed to delete ${filename}`, error);
+        }
+      }
+    },
+    async exists(filename) {
+      try {
+        await fs.access(getFullPath(path.basename(filename)), __require("node:fs").constants.F_OK);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    async download(filename) {
+      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) => controller.enqueue(new Uint8Array(chunk)));
+          nodeStream.on("end", () => controller.close());
+          nodeStream.on("error", (err) => controller.error(err));
+        },
+        cancel() {
+          nodeStream.destroy();
+        }
+      });
+    }
+  };
+}
+// src/storage/adapters/s3.ts
+import {
+  DeleteObjectCommand,
+  GetObjectCommand,
+  HeadObjectCommand,
+  PutObjectCommand,
+  S3Client
+} from "@aws-sdk/client-s3";
+import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+function createS3Adapter(config) {
+  const s3Client = new S3Client({
+    region: config.region,
+    endpoint: config.endpoint,
+    credentials: config.credentials,
+    forcePathStyle: config.forcePathStyle
+  });
+  const getFullKey = (filename) => {
+    if (config.prefix) {
+      const p = config.prefix.replace(/\/$/, "");
+      return `${p}/${filename}`;
+    }
+    return filename;
+  };
+  const getPublicUrl = (filename) => {
+    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, options) {
+      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,
+          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) {
+      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) {
+      try {
+        const command = new HeadObjectCommand({
+          Bucket: config.bucket,
+          Key: getFullKey(filename)
+        });
+        await s3Client.send(command);
+        return true;
+      } catch (error) {
+        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, operation, expiresInSeconds = 3600) {
+      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) {
+      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();
+      } catch (error) {
+        if (error instanceof StorageError)
+          throw error;
+        throw new StorageError("s3", "download", `Failed to download ${filename} from S3 bucket ${config.bucket}`, error);
+      }
+    }
+  };
+}
+export {
+  createS3Adapter,
+  createR2Storage,
+  createLocalAdapter,
+  StorageError,
+  Invalidmime_typeError,
+  FileTooLargeError
+};

package/dist/storage/adapters/cloudflare-r2.d.ts

@@ -0,0 +1,6 @@
+import type { R2Bucket } from "@cloudflare/workers-types";
+import type { StorageAdapter, StorageAdapterConfig } from "../types";
+export interface R2AdapterConfig extends StorageAdapterConfig {
+    bucketBinding: R2Bucket;
+}
+export declare function createR2Storage(config: R2AdapterConfig): StorageAdapter;

package/dist/storage/adapters/local.d.ts

@@ -0,0 +1,6 @@
+import type { StorageAdapter, StorageAdapterConfig } from "../types";
+export interface LocalAdapterConfig extends StorageAdapterConfig {
+    uploadDir: string;
+    publicUrl: string;
+}
+export declare function createLocalAdapter(config: LocalAdapterConfig): StorageAdapter;

package/dist/storage/adapters/s3.d.ts

@@ -0,0 +1,13 @@
+import type { StorageAdapter, StorageAdapterConfig } 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 declare function createS3Adapter(config: S3AdapterConfig): StorageAdapter;

package/dist/storage/errors.d.ts

@@ -0,0 +1,12 @@
+export declare class StorageError extends Error {
+    provider: string;
+    operation: "upload" | "delete" | "download" | "presign" | "exists";
+    originalError: unknown;
+    constructor(provider: string, operation: "upload" | "delete" | "download" | "presign" | "exists", message: string, originalError?: unknown);
+}
+export declare class FileTooLargeError extends StorageError {
+    constructor(provider: string, maxBytes: number, actualBytes: number);
+}
+export declare class Invalidmime_typeError extends StorageError {
+    constructor(provider: string, allowedTypes: string[], actualType: string);
+}

package/dist/storage/index.d.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/dist/storage/types.d.ts

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