File Uploads

Stream allows you to easily upload files to our CDN and use them as attachments for activities and comments.

This functionality defaults to using the Stream CDN. If you would like, you can easily change the logic to upload to your own CDN of choice.

How to upload a file or image

// In order to upload a file or image, you can use the `StreamAttachmentUploader`.
// The StreamAttachmentUploader is a thread-safe, asynchronous uploader for `AnyStreamAttachment` objects.
// It wraps a lower-level CDNClient implementation to simplify file uploads and provide progress updates and completion callbacks.
import StreamCore
import StreamFeeds

func uploadAttachmentPayloads(_ attachments: [AnyAttachmentPayload], in feed: FeedId) async throws -> [Attachment] {
    let dataAttachments: [StreamAttachment<Data>] = try attachments
        .filter { $0.localFileURL != nil }
        .enumerated()
        .compactMap { index, attachment in
            guard let localFileURL = attachment.localFileURL else { return nil }
            let attachmentFile = try AttachmentFile(url: localFileURL)
            let payloadData = try JSONEncoder().encode(attachment.payload)
            try Task.checkCancellation()
            return StreamAttachment<Data>(
                id: AttachmentId(
                    fid: feed.rawValue,
                    activityId: UUID().uuidString,
                    index: index
                ),
                type: attachment.type,
                payload: payloadData,
                downloadingState: nil,
                uploadingState: .init(
                    localFileURL: localFileURL,
                    state: .pendingUpload,
                    file: attachmentFile
                )
            )
    }
    return try await attachmentUploader.upload(dataAttachments, progress: nil)
        .map { uploadedAttachment in
            Attachment(
                assetUrl: uploadedAttachment.remoteURL.absoluteString,
                custom: [:],
                imageUrl: uploadedAttachment.remoteURL.absoluteString
            )
        }
}

// You can then use these uploads as attachments when creating activity:

let activity = try await feed.addActivity(
    request: .init(
        attachments: uploadedAttachments,
        text: "Hi",
        type: "activity"
    )
)

// Alternatively, you can directly pass local attachments and they will be automatically uploaded:

let payloads: [AnyAttachmentPayload] = [] // set payloads
let activity = try await feed.addActivity(
    request: .init(
        attachmentUploads: payloads,
        text: "Hi",
        type: "activity"
    )
)

// To upload a file or image, you can use the `FeedUploader` exposed by `FeedsClient`.
// Just create a `FeedUploadPayload` and pass it to the `upload` function.
val file = File("theFilePath")
val payload = FeedUploadPayload(file, FileType.Image("jpeg"))
val result: Result<UploadedFile> = client.uploader.upload(
    payload = payload,
    // Optionally, you can provide a listener to track the upload progress.
    progress = { progress -> println("Upload progress ${progress}%") }
)
result.fold(
    onSuccess = { uploadedFile -> println("File uploaded: ${uploadedFile.fileUrl}") },
    onFailure = { error -> println("Failed to upload file: ${error.message}") }
)

// You can also automatically upload files as attachments when creating an activity
// by passing a list of payloads in the `attachmentUploads` field of the request
val request = FeedAddActivityRequest(
    type = "activity",
    text = "Look at my beautiful image!",
    feeds = listOf("<feed id>"),
    attachmentUploads = listOf(
        FeedUploadPayload(myFile, FileType.Other("jpeg")),
    )
)
feed.addActivity(
    request = request,
    attachmentUploadProgress = { payload, progress ->
        println("${payload.file.name} upload progress: ${progress}%")
    }
)

// It also works for comments!
val request = ActivityAddCommentRequest(
    comment = "Look at my beautiful image!",
    activityId = "<activity id>",
    attachmentUploads = listOf(
        FeedUploadPayload(myFile, FileType.Other("jpeg")),
    )

)
feed.addComment(
    request = request,
    attachmentUploadProgress = { payload, progress ->
        println("${payload.file.name} upload progress: ${progress}%")
    }
)

import { isImageFile } from "@stream-io/feeds-client";
import type { StreamFile } from "@stream-io/feeds-client";

const files: null | StreamFile[]; // the return value of a file input

const requests = [];
for (let file of [...(files ?? [])]) {
  if (isImageFile(file)) {
    requests.push(
      client.uploadImage({
        file,
        // Optionally provide resize params
        upload_sizes: [
          {
            width: 100,
            height: 100,
            resize: "scale",
            crop: "center",
          },
        ],
      }),
    );
  } else {
    requests.push(
      client.uploadFile({
        file,
      }),
    );
  }
}
const fileResponses = await Promise.all(requests);

await feed.addActivity({
  type: "post",
  text: activityText,
  attachments: fileResponses.map((response, index) => {
    const isImage = isImageFile(files![index]);
    return {
      type: isImage ? "image" : "file",
      [isImage ? "image_url" : "asset_url"]: response?.file,
      custom: {},
    };
  }),
});

import { isImageFile } from "@stream-io/feeds-react-sdk";
import type { StreamFile } from "@stream-io/feeds-react-sdk";

const files: null | StreamFile[]; // the return value of a file input

const requests = [];
for (let file of [...(files ?? [])]) {
  if (isImageFile(file)) {
    requests.push(
      client.uploadImage({
        file,
        // Optionally provide resize params
        upload_sizes: [
          {
            width: 100,
            height: 100,
            resize: "scale",
            crop: "center",
          },
        ],
      }),
    );
  } else {
    requests.push(
      client.uploadFile({
        file,
      }),
    );
  }
}
const fileResponses = await Promise.all(requests);

await feed.addActivity({
  type: "post",
  text: activityText,
  attachments: fileResponses.map((response, index) => {
    const isImage = isImageFile(files![index]);
    return {
      type: isImage ? "image" : "file",
      [isImage ? "image_url" : "asset_url"]: response?.file,
      custom: {},
    };
  }),
});

import { isImageFile } from "@stream-io/feeds-react-native-sdk";
import type { StreamFile } from "@stream-io/feeds-react-native-sdk";

const files: null | StreamFile[]; // the return value of a file input

const requests = [];
for (let file of [...(files ?? [])]) {
  if (isImageFile(file)) {
    requests.push(
      client.uploadImage({
        file,
        // Optionally provide resize params
        upload_sizes: [
          {
            width: 100,
            height: 100,
            resize: "scale",
            crop: "center",
          },
        ],
      }),
    );
  } else {
    requests.push(
      client.uploadFile({
        file,
      }),
    );
  }
}
const fileResponses = await Promise.all(requests);

await feed.addActivity({
  type: "post",
  text: activityText,
  attachments: fileResponses.map((response, index) => {
    const isImage = isImageFile(files![index]);
    return {
      type: isImage ? "image" : "file",
      [isImage ? "image_url" : "asset_url"]: response?.file,
      custom: {},
    };
  }),
});

// Create an instance of AttachmentFile with the file path
//
// Note: On web, use `AttachmentFile.fromData`. Or if you are working with
// plugins which provide XFile then use `AttachmentFile.fromXFile`.
final file = AttachmentFile('path/to/file');

// Create a StreamAttachment with the file and type (image, video, file)
final streamAttachment = StreamAttachment(
  file: file,
  type: AttachmentType.image,
  custom: {'width': 600, 'height': 400},
);

// Upload the attachment
final result = await attachmentUploader.upload(
  streamAttachment,
  // Optionally track upload progress
  onProgress: (progress) {
    // Handle progress updates
  },
);

// Map the result to an Attachment model to send with an activity
final uploadedAttachment = result.getOrThrow();
final attachmentReadyToBeSent = Attachment(
  imageUrl: uploadedAttachment.remoteUrl,
  assetUrl: uploadedAttachment.remoteUrl,
  thumbUrl: uploadedAttachment.thumbnailUrl,
  custom: {...?uploadedAttachment.custom},
);

// Add an activity with the uploaded attachment
final activity = await feed.addActivity(
  request: FeedAddActivityRequest(
    attachments: uploadedAttachments,
    text: 'look at NYC',
    type: 'post',
  ),
);

// You can also automatically upload files as attachments when creating an activity
// by passing a list of payloads in the `attachmentUploads` field of the request

// Create a list of attachments to upload
final attachmentUploads = <StreamAttachment>[];

// Add an activity with the attachment needing upload
final activity = await feed.addActivity(
  request: FeedAddActivityRequest(
    attachmentUploads: attachmentUploads,
    text: 'look at NYC',
    type: 'post',
  ),
);

// It also works for comments!

// Create a list of attachments to upload
final attachmentUploads = <StreamAttachment>[];

// Add a comment with the attachment needing upload
final comment = await activity.addComment(
  request: ActivityAddCommentRequest(
    attachmentUploads: attachmentUploads,
    activityId: activity.activityId,
    comment: 'look at NYC',
  ),
);

import fs from "fs";
import path from "path";
import { File } from "buffer";

const filePath = path.join(__dirname, "assets", "test-image.jpg");
const fileBuffer = fs.readFileSync(filePath);

const response = await client.uploadImage({
  file: new File([fileBuffer], "test-image.jpg"),
  user: { id: user.id },
  upload_sizes: [
    {
      width: 100,
      height: 100,
      resize: "scale",
      crop: "center",
    },
  ],
});

const filePath2 = path.join(__dirname, "assets", "test-file.pdf");
const fileBuffer2 = fs.readFileSync(filePath2);

const response = await client.uploadFile({
  file: new File([fileBuffer2], "test-file.pdf"),
  user: { id: user.id },
});

import (
    "context"
    "os"
    "github.com/GetStream/getstream-go/v3"
)

// Upload an image file
tmpFile, err := os.CreateTemp("", "test-image-*.jpg")
if err != nil {
    log.Fatal(err)
}
defer os.Remove(tmpFile.Name())

// Write some test image content (in real usage, use actual image data)
tmpFile.WriteString("fake-image-data")
tmpFile.Close()

uploadReq := &getstream.UploadImageRequest{
    File: getstream.PtrTo(tmpFile.Name()),
    UploadSizes: []getstream.ImageSize{
        {Width: getstream.PtrTo(100), Height: getstream.PtrTo(100), Resize: getstream.PtrTo("scale"), Crop: getstream.PtrTo("center")},
    },
    User: &getstream.OnlyUserID{
        ID: "john",
    },
}

imageResponse, err := client.UploadImage(context.Background(), uploadReq)
if err != nil {
    log.Fatal("Error uploading image:", err)
}

// Upload a regular file
tmpFile2, err := os.CreateTemp("", "test-file-*.pdf")
if err != nil {
    log.Fatal(err)
}
defer os.Remove(tmpFile2.Name())

tmpFile2.WriteString("fake-file-data")
tmpFile2.Close()

fileUploadReq := &getstream.UploadFileRequest{
    File: getstream.PtrTo(tmpFile2.Name()),
    User: &getstream.OnlyUserID{
        ID: "john",
    },
}

fileResponse, err := client.UploadFile(context.Background(), fileUploadReq)
if err != nil {
    log.Fatal("Error uploading file:", err)
}

// Use the uploaded file URLs in activity attachments
feedsClient := client.Feeds()
response, err := feedsClient.AddActivity(context.Background(), &getstream.AddActivityRequest{
    Type:   "post",
    Feeds:  []string{"user:john"},
    Text:   getstream.PtrTo("Look at this amazing view of NYC!"),
    UserID: getstream.PtrTo("john"),
    Attachments: []getstream.Attachment{
        {
            ImageUrl: imageResponse.Data.File,
            Type:     getstream.PtrTo("image"),
            Title:    getstream.PtrTo("NYC Skyline"),
        },
    },
    Custom: map[string]any{
        "location": "New York City",
        "camera":   "iPhone 15 Pro",
    },
})
if err != nil {
    log.Fatal("Error adding activity:", err)
}

// Upload an image file
UploadImageRequest imageUploadRequest = UploadImageRequest.builder()
    .file("/path/to/image.jpg")
    .user(OnlyUserID.builder().id("john").build())
    .uploadSizes(List.of(
        ImageSize.builder()
            .width(100)
            .height(100)
            .resize("scale")
            .crop("center")
            .build()
    ))
    .build();

ImageUploadResponse imageResponse = client.uploadImage(imageUploadRequest).execute().getData();
String imageUrl = imageResponse.getFile();

// Upload a regular file
UploadFileRequest fileUploadRequest = UploadFileRequest.builder()
    .file("/path/to/document.pdf")
    .user(OnlyUserID.builder().id("john").build())
    .build();

FileUploadResponse fileResponse = client.uploadFile(fileUploadRequest).execute().getData();
String fileUrl = fileResponse.getFile();

// Create activity with uploaded attachments
Map<String, Object> customData = new HashMap<>();
customData.put("location", "New York City");
customData.put("camera", "iPhone 15 Pro");

AddActivityRequest activity = AddActivityRequest.builder()
    .type("post")
    .feeds(List.of("user:john"))
    .text("Look at this amazing view of NYC!")
    .userID("john")
    .attachments(List.of(
        Attachment.builder()
            .imageUrl(imageUrl)
            .type("image")
            .title("NYC Skyline")
            .build()
    ))
    .custom(customData)
    .build();

AddActivityResponse response = feeds.addActivity(activity).execute().getData();

// Upload an image file
$imageUploadRequest = new GeneratedModels\ImageUploadRequest(
    file: base64_encode(file_get_contents('/path/to/image.jpg')),
    user: new GeneratedModels\OnlyUserID(id: $testUserId),
    // Optionally provide resize params
    uploadSizes: [
        [
            'width' => 100,
            'height' => 100,
            'resize' => 'scale',
            'crop' => 'center',
        ]
    ]
);
$imageResponse = $client->uploadImageGlobal($imageUploadRequest);
$imageUrl = $imageResponse->getData()->file;

// Upload a regular file
$fileUploadRequest = new GeneratedModels\FileUploadRequest(
    file: base64_encode(file_get_contents('/path/to/document.pdf')),
    user: new GeneratedModels\OnlyUserID(id: $testUserId)
);
$fileResponse = $client->uploadFileGlobal($fileUploadRequest);
$fileUrl = $fileResponse->getData()->file;

// Create activity with uploaded attachments
$activity = new GeneratedModels\AddActivityRequest(
    type: 'post',
    feeds: [$testFeed->getFeedIdentifier()],
    text: 'Look at this amazing view of NYC!',
    userID: $testUserId,
    attachments: [
        new GeneratedModels\Attachment(
            imageUrl: $imageUrl,
            type: 'image',
            title: 'NYC Skyline'
        )
    ],
    custom: (object)[
        'location' => 'New York City',
        'camera' => 'iPhone 15 Pro'
    ]
);
$response = $feedsClient->addActivity($activity);

// Upload an image file
var imageUploadRequest = new ImageUploadRequest
{
    File = "/path/to/image.jpg",
    User = new OnlyUserID
    {
        ID = "john"
    },
    // Optionally provide resize params
    UploadSizes = new List<ImageSize>
    {
        new ImageSize { Width = 100, Height = 100, Resize = "scale", Crop = "center" }
    }
};
var imageResponse = await client.ImageUploadAsync(imageUploadRequest);
var imageUrl = imageResponse.Data.File;

// Upload a regular file
var fileUploadRequest = new FileUploadRequest
{
    File = "/path/to/document.pdf",
    User = new OnlyUserID
    {
        ID = "john"
    }
};
var fileResponse = await client.FileUploadAsync(fileUploadRequest);
var fileUrl = fileResponse.Data.File;

// Create activity with uploaded attachments
var activity = new AddActivityRequest
{
    Type = "post",
    Text = "Look at this amazing view of NYC!",
    UserID = "john",
    Feeds = new List<string> { "user:john" },
    Attachments = new List<Attachment>
    {
        new Attachment
        {
            ImageUrl = imageUrl,
            Type = "image",
            Title = "NYC Skyline"
        }
    },
    Custom = new Dictionary<string, object>
    {
        ["location"] = "New York City",
        ["camera"] = "iPhone 15 Pro"
    }
};
var response = await feedsClient.AddActivityAsync(activity);

response = self.client.feeds.add_activity(
    type="post",
    feeds=[self.test_feed.get_feed_identifier()],
    text="Look at this amazing view of NYC!",
    user_id=self.test_user_id,
    attachments=[
        Attachment(
            custom={},
            image_url="https://example.com/nyc-skyline.jpg",
            type="image",
            title="NYC Skyline",
        )
    ],
    custom={"location": "New York City", "camera": "iPhone 15 Pro"},
)

require 'getstream_ruby'
require 'base64'

# Upload an image file
image_data = Base64.encode64(File.read('/path/to/image.jpg'))
image_upload_request = GetStream::Generated::Models::ImageUploadRequest.new(
  file: image_data,
  user: GetStream::Generated::Models::OnlyUserID.new(id: 'john'),
  upload_sizes: [
    {
      width: 100,
      height: 100,
      resize: 'scale',
      crop: 'center'
    }
  ]
)
image_response = client.upload_image(image_upload_request)
image_url = image_response.data.file

# Upload a regular file
file_data = Base64.encode64(File.read('/path/to/document.pdf'))
file_upload_request = GetStream::Generated::Models::FileUploadRequest.new(
  file: file_data,
  user: GetStream::Generated::Models::OnlyUserID.new(id: 'john')
)
file_response = client.upload_file(file_upload_request)
file_url = file_response.data.file

# Create activity with uploaded attachments
activity_request = GetStream::Generated::Models::AddActivityRequest.new(
  type: 'post',
  feeds: ['user:john'],
  text: 'Look at this amazing view of NYC!',
  user_id: 'john',
  attachments: [
    GetStream::Generated::Models::Attachment.new(
      image_url: image_url,
      type: 'image',
      title: 'NYC Skyline'
    )
  ],
  custom: {
    location: 'New York City',
    camera: 'iPhone 15 Pro'
  }
)
response = client.feeds.add_activity(activity_request)

The upload_sizes array lets you create specific versions of the uploaded image. It's also possible to resize images on the fly (see Image resizing section), but if you know what versions you'll need beforehand, it's faster to create them in advance.

Deleting Files and Images

We expose two methods for deleting files and images, client.deleteImage and client.deleteFile

// Delete an image from the CDN
await client.deleteImage(url: 'https://mycdn.com/image.png');

// Delete a file from the CDN
await client.deleteFile(url: 'https://mycdn.com/file.pdf');

_, err = client.DeleteImage(context.Background(), &getstream.DeleteImageRequest{
  Url: getstream.PtrTo("<image URL>"),
})

_, err = client.DeleteFile(context.Background(), &getstream.DeleteFileRequest{
  Url: getstream.PtrTo("<file URL>"),
})

// Deleting images and files
client.deleteImage(DeleteImageRequest.builder().url("<image URL>").build());
client.deleteFile(DeleteFileRequest.builder().url("<file URL>").build());

// Delete an image from the CDN
$client->deleteImageGlobal(url: 'https://cdn.stream-io-cdn.com/image.png');

// Delete a file from the CDN
$client->deleteFileGlobal(url: 'https://cdn.stream-io-cdn.com/file.pdf');

// Deleting images and files
await client.DeleteImageAsync(new DeleteImageRequest { Url = "<image URL>" });
await client.DeleteFileAsync(new DeleteFileRequest { Url = "<file URL>" });

# Delete an image from the CDN
client.delete_image('https://cdn.stream-io-cdn.com/image.png')

# Delete a file from the CDN
client.delete_file('https://cdn.stream-io-cdn.com/file.pdf')

Requirements for Images

Stream supported image types are: image/bmp, image/gif, image/jpeg, image/png, image/webp, image/heic, image/heic-sequence, image/heif, image/heif-sequence, image/svg+xml.
You can set a more restrictive list for your application if needed.
The maximum file size is 100MB.

Requirements for Files

Stream will not block any file types from uploading, however, different clients may handle different types differently or not at all.
You can set a more restrictive list for your application if needed.
The maximum file size is 100MB.

How to Allow/Block file extensions

Stream will allow any file extension. If you want to be more restrictive for an application, this is can be set via API or by logging into your dashboard.

To update via the dashboard, login and go to the Chat Overview page >> Upload Configuration.
API updates are made using UpdateAppSettings.

Image resizing

You can automatically resize an image appending query parameters to a valid image link stored on the Stream CDN.

An image can only be resized if the total pixel count of the source image is 16.800.000 or less. Attempting to resize an image with more pixels will result in an API error. An image of 4000 by 4000 would be accepted, but an image of 4100 by 4100 would pass the upper treshold for resizing.

There are four supported params - all of them are optional and can be used interchangeably:

Parameter	Type	Values	Description
w	number		Width
h	number		Height
resize	string	clip , crop , scale , fill	The resizing mode
crop	string	center , top , bottom , left , right	The cropping direction during resize

Resized images will count against your stored files quota.

Access control and link expiration

The Stream CDN URL returned during the upload contains a signature that validates the access to the file it points to. Only the members of a channel a file was uploaded to can see the attachment and its unique, signed link. Links can only be accessed with a valid signature, which also protects against enumeration attacks.

Whenever messages containing your attachments are retrieved (i.e., when querying a channel), the attachment links will contain a new, fresh signature.

A single Stream CDN URL expires after 14 days, after which its signature will stop working and the link won't be valid anymore. You can check when a link will expire by comparing the current time with the Unix timestamp in the Expires parameter of the link's query: https://us-east.stream-io-cdn.com/0000/images/foo.png?...& Expires=1602666347 &...

Using Your Own CDN

All our SDKs make it easy to use your own CDN for uploads. The code examples below show how to change where files are uploaded:

// Your custom implementation of `CDNClient`.
class CustomCDN: CDNClient, @unchecked Sendable {
    static var maxAttachmentSize: Int64 { 20 * 1024 * 1024 }

    func uploadAttachment(
        _ attachment: AnyStreamAttachment,
        progress: (@Sendable (Double) -> Void)?,
        completion: @Sendable @escaping (Result<URL, Error>) -> Void
    ) {
        if let imageAttachment = attachment.attachment(payloadType: ImageAttachmentPayload.self) {
            // Your code to handle image uploading.
            // Don't forget to call `progress(x)` to report back the uploading progress.
            // When the uploading is finished, call the completion block with the result.
            uploadImage(imageAttachment, progress: progress)
        } else if let fileAttachment = attachment.attachment(payloadType: FileAttachmentPayload.self) {
            // Your code to handle file uploading.
            // Don't forget to call `progress(x)` to report back the uploading progress.
            // When the uploading is finished, call the completion block with the result.
            uploadFile(fileAttachment, progress: progress)
        } else {
            // Unsupported attachment type
            struct UnsupportedAttachmentType: Error {}
            completion(.failure(UnsupportedAttachmentType()))
        }
    }
}

// Assign your custom CDN client to the `FeedsConfig` instance you use
// when creating `FeedsClient`.
let config = FeedsConfig(customCDNClient: CustomCDN())
let client = FeedsClient(
    apiKey: APIKey("api key"),
    user: User(id: "user_id"),
    token: UserToken("my token"),
    feedsConfig: config
)

// Your custom implementation of `FeedUploader`
class CustomUploader : FeedUploader {
    override suspend fun upload(
        payload: FeedUploadPayload,
        progress: ((Double) -> Unit)?
    ): Result<UploadedFile> {
        return when (payload.type) {
            is FileType.Image -> {
                // Your code to handle image uploading
                // Don't forget to call progress(x) to report back the uploading progress
                uploadImage(payload.file, progress)
            }

            is FileType.Other -> {
                // Your code to handle file uploading
                // Don't forget to call progress(x) to report back the uploading progress
                uploadFile(payload.file, progress)
            }
        }
    }
}

// Assign your custom uploader to the `FeedsConfig` instance you use when creating `FeedsClient`
val config = FeedsConfig(customUploader = CustomUploader())
val client = FeedsClient(
    feedsConfig = config
    // Other arguments
)

// Your custom implementation of CdnClient
class CustomCDN implements CdnClient {
  @override
  Future<Result<UploadedFile>> uploadFile(
    AttachmentFile file, {
    ProgressCallback? onProgress,
    CancelToken? cancelToken,
  }) {
    // Use your own CDN upload logic here.
    // For example, you might upload the file to AWS S3, Google Cloud Storage, etc.
    // After uploading, return a Result<UploadedFile> with the file URLs.
    //
    // Note: Make sure to handle progress updates and cancellation if needed.
    return uploadToYourOwnCdn(
      file,
      onProgress: onProgress,
      cancelToken: cancelToken,
    );
  }

  @override
  Future<Result<UploadedFile>> uploadImage(
    AttachmentFile image, {
    ProgressCallback? onProgress,
    CancelToken? cancelToken,
  }) {
    // Use your own CDN upload logic here.
    // For example, you might upload the image to AWS S3, Google Cloud Storage, etc.
    // After uploading, return a Result<UploadedFile> with the image URLs.
    //
    // Note: Make sure to handle progress updates and cancellation if needed.
    return uploadToYourOwnCdn(
      image,
      onProgress: onProgress,
      cancelToken: cancelToken,
    );
  }

  @override
  Future<Result<void>> deleteFile(
    String url, {
    CancelToken? cancelToken,
  }) {
    // Use your own CDN deletion logic here.
    // For example, you might delete the file from AWS S3, Google Cloud Storage, etc.
    // After deleting, return a Result<void> indicating success or failure.
    //
    // Note: Make sure to handle cancellation if needed.
    return deleteFromYourOwnCdn(
      url,
      cancelToken: cancelToken,
    );
  }

  @override
  Future<Result<void>> deleteImage(
    String url, {
    CancelToken? cancelToken,
  }) {
    // Use your own CDN deletion logic here.
    // For example, you might delete the image from AWS S3, Google Cloud Storage, etc.
    // After deleting, return a Result<void> indicating success or failure.
    //
    // Note: Make sure to handle cancellation if needed.
    return deleteFromYourOwnCdn(
      url,
      cancelToken: cancelToken,
    );
  }
}

Future<void> usingYourOwnCdn() async {
  // Create a config with your custom CDN client
  final config = FeedsConfig(cdnClient: CustomCDN());

  // Initialize the StreamFeedsClient with the custom config
  final client = StreamFeedsClient(
    apiKey: 'your_api_key',
    user: const User(id: 'user_id'),
    config: config,
  );
}

// No need to set anything, just call your own CDN instead of client.uploadFile / client.uploadImage

Comments

User Mentions