medusa-plugin-cloudflare-images 0.1.0

package/.medusa/server/src/providers/cloudflare-images/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@medusajs/types").ModuleProviderExports;
+export default _default;

package/.medusa/server/src/providers/cloudflare-images/index.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@medusajs/framework/utils");
+const service_1 = __importDefault(require("./service"));
+exports.default = (0, utils_1.ModuleProvider)(utils_1.Modules.FILE, {
+    services: [service_1.default],
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvcHJvdmlkZXJzL2Nsb3VkZmxhcmUtaW1hZ2VzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBQUEscURBQW1FO0FBRW5FLHdEQUEyRDtBQUUzRCxrQkFBZSxJQUFBLHNCQUFjLEVBQUMsZUFBTyxDQUFDLElBQUksRUFBRTtJQUMxQyxRQUFRLEVBQUUsQ0FBQyxpQkFBbUMsQ0FBQztDQUNoRCxDQUFDLENBQUEifQ==

package/.medusa/server/src/providers/cloudflare-images/service.d.ts

@@ -0,0 +1,79 @@
+import type { FileTypes, Logger } from "@medusajs/framework/types";
+import { AbstractFileProviderService } from "@medusajs/framework/utils";
+import { PassThrough, Readable } from "node:stream";
+type InjectedDependencies = {
+    logger: Logger;
+};
+type CloudflareImagesBaseOptions = {
+    account_id: string;
+    api_token: string;
+    variant?: string;
+    prefix?: string;
+};
+type CloudflareImagesDeliveryOptions = {
+    account_hash: string;
+    delivery_url?: string;
+} | {
+    account_hash?: string;
+    delivery_url: string;
+};
+type CloudflareImagesFileProviderOptions = CloudflareImagesBaseOptions & CloudflareImagesDeliveryOptions;
+type PartialCloudflareImagesFileProviderOptions = Partial<CloudflareImagesBaseOptions & {
+    account_hash: string;
+    delivery_url: string;
+}>;
+type NormalizedCloudflareImagesFileProviderOptions = {
+    account_id: string;
+    api_token: string;
+    account_hash?: string;
+    delivery_url?: string;
+    variant: string;
+    prefix: string;
+};
+type CloudflareImagesError = {
+    code?: number;
+    message?: string;
+};
+type CloudflareImageResult = {
+    id: string;
+    filename?: string;
+    variants?: string[];
+};
+type UploadBufferInput = {
+    content: Buffer;
+    filename: string;
+    mimeType: string;
+    fileKey?: string;
+};
+declare class CloudflareImagesFileProviderService extends AbstractFileProviderService {
+    static identifier: string;
+    protected readonly logger_: Logger;
+    protected readonly options_: NormalizedCloudflareImagesFileProviderOptions;
+    constructor({ logger }: InjectedDependencies, options: CloudflareImagesFileProviderOptions);
+    static validateOptions(options: PartialCloudflareImagesFileProviderOptions): void;
+    upload(file: FileTypes.ProviderUploadFileDTO): Promise<FileTypes.ProviderFileResultDTO>;
+    getUploadStream(fileData: FileTypes.ProviderUploadStreamDTO): Promise<{
+        writeStream: PassThrough;
+        promise: Promise<FileTypes.ProviderFileResultDTO>;
+        url: string;
+        fileKey: string;
+    }>;
+    delete(files: FileTypes.ProviderDeleteFileDTO | FileTypes.ProviderDeleteFileDTO[]): Promise<void>;
+    getPresignedDownloadUrl(fileData: FileTypes.ProviderGetFileDTO): Promise<string>;
+    getPresignedUploadUrl(fileData: FileTypes.ProviderGetPresignedUploadUrlDTO): Promise<FileTypes.ProviderFileResultDTO>;
+    getDownloadStream(fileData: FileTypes.ProviderGetFileDTO): Promise<Readable>;
+    getAsBuffer(fileData: FileTypes.ProviderGetFileDTO): Promise<Buffer>;
+    protected uploadBuffer(input: UploadBufferInput): Promise<CloudflareImageResult>;
+    protected parseCloudflareResponse<T>(response: Response, action: string): Promise<T>;
+    protected streamToBuffer(stream: Readable): Promise<Buffer>;
+    protected createCustomFileKey(): string | undefined;
+    protected getDeliveryUrl(fileKey: string): string;
+    protected getExpiry(expiresIn: number): string;
+    protected normalizePrefix(prefix?: string): string;
+    protected formatCloudflareErrors(errors?: CloudflareImagesError[]): string;
+    protected imagesEndpoint(): string;
+    protected directUploadEndpoint(): string;
+    protected imageEndpoint(fileKey: string): string;
+    protected authHeaders(): HeadersInit;
+}
+export default CloudflareImagesFileProviderService;

package/.medusa/server/src/providers/cloudflare-images/service.js

@@ -0,0 +1,228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@medusajs/framework/utils");
+const node_crypto_1 = require("node:crypto");
+const node_stream_1 = require("node:stream");
+class CloudflareImagesFileProviderService extends utils_1.AbstractFileProviderService {
+    constructor({ logger }, options) {
+        super();
+        this.logger_ = logger;
+        this.options_ = {
+            account_id: options.account_id,
+            api_token: options.api_token,
+            account_hash: options.account_hash,
+            delivery_url: options.delivery_url?.replace(/\/$/, ""),
+            variant: options.variant || "public",
+            prefix: this.normalizePrefix(options.prefix),
+        };
+    }
+    static validateOptions(options) {
+        if (!options.account_id) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Cloudflare Images provider requires account_id");
+        }
+        if (!options.api_token) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Cloudflare Images provider requires api_token");
+        }
+        if (!options.account_hash && !options.delivery_url) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Cloudflare Images provider requires account_hash or delivery_url");
+        }
+    }
+    async upload(file) {
+        if (!file?.filename) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "No filename provided");
+        }
+        if (!file.content) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "No file content provided");
+        }
+        const content = Buffer.from(file.content, "base64");
+        const result = await this.uploadBuffer({
+            content,
+            filename: file.filename,
+            mimeType: file.mimeType,
+            fileKey: this.createCustomFileKey(),
+        });
+        return {
+            key: result.id,
+            url: this.getDeliveryUrl(result.id),
+        };
+    }
+    async getUploadStream(fileData) {
+        if (!fileData?.filename) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "No filename provided");
+        }
+        const fileKey = this.createCustomFileKey();
+        if (!fileKey) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_ALLOWED, "Cloudflare Images upload streams require the prefix option so the file key can be known before upload");
+        }
+        const writeStream = new node_stream_1.PassThrough();
+        const url = this.getDeliveryUrl(fileKey);
+        const promise = this.streamToBuffer(writeStream)
+            .then((content) => this.uploadBuffer({
+            content,
+            filename: fileData.filename,
+            mimeType: fileData.mimeType,
+            fileKey,
+        }))
+            .then((result) => ({
+            key: result.id,
+            url: this.getDeliveryUrl(result.id),
+        }));
+        return {
+            writeStream,
+            promise,
+            url,
+            fileKey,
+        };
+    }
+    async delete(files) {
+        const fileArray = Array.isArray(files) ? files : [files];
+        await Promise.all(fileArray.map(async (file) => {
+            if (!file?.fileKey) {
+                return;
+            }
+            const response = await fetch(this.imageEndpoint(file.fileKey), {
+                method: "DELETE",
+                headers: this.authHeaders(),
+            });
+            if (response.status === 404) {
+                this.logger_.warn(`Cloudflare image ${file.fileKey} was already deleted`);
+                return;
+            }
+            await this.parseCloudflareResponse(response, `delete Cloudflare image ${file.fileKey}`);
+        }));
+    }
+    async getPresignedDownloadUrl(fileData) {
+        if (!fileData?.fileKey) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "No fileKey provided");
+        }
+        return this.getDeliveryUrl(fileData.fileKey);
+    }
+    async getPresignedUploadUrl(fileData) {
+        if (!fileData?.filename) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "No filename provided");
+        }
+        const fileKey = this.createCustomFileKey();
+        const formData = new FormData();
+        formData.append("requireSignedURLs", "false");
+        if (fileKey) {
+            formData.append("id", fileKey);
+        }
+        if (fileData.expiresIn) {
+            formData.append("expiry", this.getExpiry(fileData.expiresIn));
+        }
+        const response = await fetch(this.directUploadEndpoint(), {
+            method: "POST",
+            headers: this.authHeaders(),
+            body: formData,
+        });
+        const result = await this.parseCloudflareResponse(response, "create Cloudflare direct upload URL");
+        return {
+            key: result.id,
+            url: result.uploadURL,
+        };
+    }
+    async getDownloadStream(fileData) {
+        const buffer = await this.getAsBuffer(fileData);
+        return node_stream_1.Readable.from(buffer);
+    }
+    async getAsBuffer(fileData) {
+        if (!fileData?.fileKey) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "No fileKey provided");
+        }
+        const response = await fetch(this.getDeliveryUrl(fileData.fileKey));
+        if (!response.ok) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, `Failed to fetch Cloudflare image ${fileData.fileKey}: ${response.status} ${response.statusText}`);
+        }
+        return Buffer.from(await response.arrayBuffer());
+    }
+    async uploadBuffer(input) {
+        const formData = new FormData();
+        const blob = new Blob([new Uint8Array(input.content)], { type: input.mimeType });
+        formData.append("file", blob, input.filename);
+        formData.append("requireSignedURLs", "false");
+        if (input.fileKey) {
+            formData.append("id", input.fileKey);
+        }
+        formData.append("metadata", JSON.stringify({
+            original_filename: input.filename,
+            source: "medusa",
+        }));
+        const response = await fetch(this.imagesEndpoint(), {
+            method: "POST",
+            headers: this.authHeaders(),
+            body: formData,
+        });
+        return await this.parseCloudflareResponse(response, "upload Cloudflare image");
+    }
+    async parseCloudflareResponse(response, action) {
+        const body = await response.text();
+        let payload;
+        try {
+            payload = body ? JSON.parse(body) : undefined;
+        }
+        catch {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, `Cloudflare Images failed to ${action}: invalid JSON response (${response.status})`);
+        }
+        if (!response.ok || !payload?.success) {
+            const details = this.formatCloudflareErrors(payload?.errors) || body;
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, `Cloudflare Images failed to ${action}: ${response.status} ${details}`);
+        }
+        return payload.result;
+    }
+    async streamToBuffer(stream) {
+        const chunks = [];
+        for await (const chunk of stream) {
+            chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        }
+        return Buffer.concat(chunks);
+    }
+    createCustomFileKey() {
+        if (!this.options_.prefix) {
+            return undefined;
+        }
+        return `${this.options_.prefix}${(0, node_crypto_1.randomUUID)()}`;
+    }
+    getDeliveryUrl(fileKey) {
+        const encodedKey = fileKey.split("/").map(encodeURIComponent).join("/");
+        const baseUrl = this.options_.delivery_url ||
+            `https://imagedelivery.net/${this.options_.account_hash}`;
+        return `${baseUrl}/${encodedKey}/${this.options_.variant}`;
+    }
+    getExpiry(expiresIn) {
+        const minSeconds = 2 * 60;
+        const maxSeconds = 6 * 60 * 60;
+        const seconds = Math.min(Math.max(expiresIn, minSeconds), maxSeconds);
+        return new Date(Date.now() + seconds * 1000).toISOString();
+    }
+    normalizePrefix(prefix) {
+        if (!prefix) {
+            return "";
+        }
+        return prefix.endsWith("/") ? prefix : `${prefix}/`;
+    }
+    formatCloudflareErrors(errors) {
+        if (!errors?.length) {
+            return "";
+        }
+        return errors
+            .map((error) => [error.code, error.message].filter((part) => part !== undefined).join(": "))
+            .join("; ");
+    }
+    imagesEndpoint() {
+        return `https://api.cloudflare.com/client/v4/accounts/${this.options_.account_id}/images/v1`;
+    }
+    directUploadEndpoint() {
+        return `https://api.cloudflare.com/client/v4/accounts/${this.options_.account_id}/images/v2/direct_upload`;
+    }
+    imageEndpoint(fileKey) {
+        return `${this.imagesEndpoint()}/${encodeURIComponent(fileKey)}`;
+    }
+    authHeaders() {
+        return {
+            Authorization: `Bearer ${this.options_.api_token}`,
+        };
+    }
+}
+CloudflareImagesFileProviderService.identifier = "cloudflare-images";
+exports.default = CloudflareImagesFileProviderService;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"service.js","sourceRoot":"","sources":["../../../../../src/providers/cloudflare-images/service.ts"],"names":[],"mappings":"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"}

package/README.md

@@ -0,0 +1,85 @@
+# Medusa Cloudflare Images File Provider
+
+Cloudflare Images File Module Provider for Medusa v2.
+
+This provider stores Medusa uploads in Cloudflare Images and returns delivery
+URLs that can be used by product media and custom file workflows.
+
+## Installation
+
+```bash
+pnpm add medusa-plugin-cloudflare-images
+```
+
+Use the equivalent install command for npm, yarn, or bun if needed.
+
+## Configuration
+
+Register the provider in `medusa-config.ts`:
+
+```ts
+import { defineConfig, loadEnv } from "@medusajs/framework/utils"
+
+loadEnv(process.env.NODE_ENV || "development", process.cwd())
+
+module.exports = defineConfig({
+  modules: [
+    {
+      resolve: "@medusajs/medusa/file",
+      options: {
+        providers: [
+          {
+            resolve: "medusa-plugin-cloudflare-images/providers/cloudflare-images",
+            id: "cloudflare-images",
+            options: {
+              account_id: process.env.CLOUDFLARE_IMAGES_ACCOUNT_ID,
+              api_token: process.env.CLOUDFLARE_IMAGES_API_TOKEN,
+              account_hash: process.env.CLOUDFLARE_IMAGES_ACCOUNT_HASH,
+              delivery_url: process.env.CLOUDFLARE_IMAGES_DELIVERY_URL,
+              variant: process.env.CLOUDFLARE_IMAGES_VARIANT || "public",
+              prefix: process.env.CLOUDFLARE_IMAGES_PREFIX,
+            },
+          },
+        ],
+      },
+    },
+  ],
+})
+```
+
+The Medusa File Module accepts one provider. Register this provider instead of
+the local or S3 file provider.
+
+## Options
+
+Required:
+
+```env
+CLOUDFLARE_IMAGES_ACCOUNT_ID=
+CLOUDFLARE_IMAGES_API_TOKEN=
+```
+
+Delivery configuration, at least one is required:
+
+```env
+CLOUDFLARE_IMAGES_ACCOUNT_HASH=
+CLOUDFLARE_IMAGES_DELIVERY_URL=
+```
+
+Optional:
+
+```env
+CLOUDFLARE_IMAGES_VARIANT=public
+CLOUDFLARE_IMAGES_PREFIX=products
+```
+
+Set `CLOUDFLARE_IMAGES_DELIVERY_URL` when serving through a custom delivery base
+URL. Otherwise the provider builds URLs as:
+
+```txt
+https://imagedelivery.net/<account_hash>/<image_id>/<variant>
+```
+
+`prefix` is optional for regular uploads and direct uploads. It is required for
+stream uploads because Medusa expects the provider to return the final file key
+and URL before the upload stream has completed.

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "medusa-plugin-cloudflare-images",
+  "version": "0.1.0",
+  "description": "Cloudflare Images File Module Provider for Medusa v2.",
+  "license": "MIT",
+  "keywords": [
+    "medusa-plugin-integration",
+    "medusa-v2",
+    "medusa-plugin-other",
+    "medusa",
+    "medusa-plugin",
+    "cloudflare",
+    "cloudflare-images",
+    "file-provider",
+    "image-storage"
+  ],
+  "homepage": "https://github.com/AlekseyMonakhov/medusa-plugin-cloudflare-images#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AlekseyMonakhov/medusa-plugin-cloudflare-images.git"
+  },
+  "bugs": {
+    "url": "https://github.com/AlekseyMonakhov/medusa-plugin-cloudflare-images/issues"
+  },
+  "files": [
+    ".medusa/server/src/providers",
+    "README.md"
+  ],
+  "main": "./.medusa/server/src/providers/cloudflare-images/index.js",
+  "types": "./.medusa/server/src/providers/cloudflare-images/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    "./providers/*": {
+      "types": "./.medusa/server/src/providers/*/index.d.ts",
+      "default": "./.medusa/server/src/providers/*/index.js"
+    },
+    ".": {
+      "types": "./.medusa/server/src/providers/cloudflare-images/index.d.ts",
+      "default": "./.medusa/server/src/providers/cloudflare-images/index.js"
+    }
+  },
+  "scripts": {
+    "build": "medusa plugin:build",
+    "dev": "medusa plugin:develop",
+    "prepublishOnly": "medusa plugin:build"
+  },
+  "peerDependencies": {
+    "@medusajs/framework": ">=2.8.0 <3.0.0",
+    "@medusajs/medusa": ">=2.8.0 <3.0.0"
+  },
+  "devDependencies": {
+    "@medusajs/admin-shared": "2.15.5",
+    "@medusajs/cli": "2.15.5",
+    "@medusajs/framework": "2.15.5",
+    "@medusajs/medusa": "2.15.5",
+    "@swc/core": "^1.7.28",
+    "@types/node": "^20.12.11",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.6.2"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "packageManager": "pnpm@10.33.0+sha512.10568bb4a6afb58c9eb3630da90cc9516417abebd3fabbe6739f0ae795728da1491e9db5a544c76ad8eb7570f5c4bb3d6c637b2cb41bfdcdb47fa823c8649319"
+}