Activity Feeds V3 is in closed alpha — do not use it in production (just yet).

Feed views

When to use feed views

Feed groups let you define what activities should be included in the feed and the ranking to sort these activities.

By default all feeds in the given group will have the same settings. However, you might want to experiment with different selectors and rankings. Feed views let you do that by overriding the group’s default settings.

await serverClient.feeds.createFeedView({
  id: "<view id>",
  activity_selectors: [
    {
      type: "following",
    },
  ],
  ranking: { type: "recency" },
});

viewId := "myview"
_, err = client.Feeds().CreateFeedView(context.Background(), &getstream.CreateFeedViewRequest{
    ID: viewId,
    ActivitySelectors: []getstream.ActivitySelectorConfig{
        {
            Type: getstream.PtrTo("following"),
        },
    },
    Ranking: &getstream.RankingConfig{
        Type: getstream.PtrTo("recency"),
    },
})

if err != nil {
    log.Fatal("Error creating feed view:", err)
}

$createResponse = $this->feedsV3Client->createFeedView(new GeneratedModels\CreateFeedViewRequest(
    id: $feedViewId,
));

var createResponse = await _feedsV3Client.CreateFeedViewAsync(new CreateFeedViewRequest
{
    ID = feedViewId,
    ActivitySelectors = new List<ActivitySelectorConfig>
    {
        new() { Type = "recent" }
    },
    ActivityProcessors = new List<ActivityProcessorConfig>
    {
        new() { Type = "default" }
    },
    Aggregation = new AggregationConfig
    {
        Format = "time_based"
    }
});

create_response = self.client.feeds.create_feed_view(
    id = feed_view_id,
    activity_selectors= [
        {
            "type": "recent"
        }
    ],
)

let query = FeedQuery(
    group: "user",
    id: "john",
    view: "<id of a feed view>", // Override the default view id
)
let feed = client.feed(for: query)
try await feed.getOrCreate()

val query = FeedQuery(
    group = "user",
    id = "john",
    view = "<id of a feed view>" // Override the default view id
)
val feed = client.feed(query = query)
feed.getOrCreate()

feed.getOrCreate({
  // Override the default view id
  view: "<id of a feed view>",
});

const query = FeedQuery(
  fid: FeedId(group: 'user', id: 'john'),
  view: '<id of a feed view>', // Override the default view id
);
final feed = client.feedFromQuery(query);
await feed.getOrCreate();

feed.getOrCreate({
  // Override the default view id
  view: "<id of a feed view>",
  user_id: "<user id>",
});

_, err = feed.GetOrCreate(context.Background(), &getstream.GetOrCreateFeedRequest{
    View: getstream.PtrTo("<view id>"),
    UserID: getstream.PtrTo("<user id>"),
})
if err != nil {
 log.Fatal("Error:", err)
}

testFeed = new Feed("user", testUserId, feeds);
testFeed2 = new Feed("user", testUserId2, feeds);

GetOrCreateFeedRequest feedRequest1 =
    GetOrCreateFeedRequest.builder().userID(testUserId).build();
GetOrCreateFeedRequest feedRequest2 =
    GetOrCreateFeedRequest.builder().userID(testUserId2).build();

GetOrCreateFeedResponse feedResponse1 = testFeed.getOrCreate(feedRequest1).getData();
GetOrCreateFeedResponse feedResponse2 = testFeed2.getOrCreate(feedRequest2).getData();
testFeedId = feedResponse1.getFeed().getFeed();
testFeedId2 = feedResponse2.getFeed().getFeed();

$feedResponse1 = $this->testFeed->getOrCreateFeed(
    new GeneratedModels\GetOrCreateFeedRequest(userID: $this->testUserId)
);
$feedResponse2 = $this->testFeed2->getOrCreateFeed(
    new GeneratedModels\GetOrCreateFeedRequest(userID: $this->testUserId2)
);

var feedResponse1 = await _feedsV3Client.GetOrCreateFeedAsync(
    FeedGroupID: "user",
    FeedID: _testFeedId,
    request: new GetOrCreateFeedRequest { UserID = _testUserId }
);
var feedResponse2 = await _feedsV3Client.GetOrCreateFeedAsync(
    FeedGroupID: "user",
    FeedID: _testFeedId2,
    request: new GetOrCreateFeedRequest { UserID = _testUserId2 }
);

feed_response_1 = self.test_feed.get_or_create(user_id=self.test_user_id)
feed_response_2 = self.test_feed_2.get_or_create(
    user_id=self.test_user_id_2
)

With custom feed views you can control

Activity selectors
Ranking
Aggregation

Updating feed views

It’s possible to update any custom or built-in feed views.

await serverClient.feeds.updateFeedView({
  id: "<view id to update>",
  // Fields to update
});

_, err = client.Feeds().UpdateFeedView(context.Background(), viewId, &getstream.UpdateFeedViewRequest{
    // Fields to update
})
if err != nil {
    log.Fatal("Error:", err)
}

$updateResponse = $this->feedsV3Client->updateFeedView('feedViewID', new GeneratedModels\UpdateFeedViewRequest(
    aggregation: new GeneratedModels\AggregationConfig('default')
    )
);

var updateResponse = await _feedsV3Client.UpdateFeedViewAsync("feedViewID", new UpdateFeedViewRequest
{
    ActivitySelectors = new List<ActivitySelectorConfig>
    {
        new() { Type = "popular", MinPopularity = 10 }
    },
    Aggregation = new AggregationConfig
    {
        Format = "popularity_based"
    }
});

update_response = self.client.feeds.update_feed_view(
    id="feedViewID",
    activity_selectors= [
        {
            "type": "popular",
            "min_popularity": 10
        }
    ]
)

Deleting feed views

await serverClient.feeds.deleteFeedView({
  id: "view id to delete",
});

_, err = client.Feeds().DeleteFeedView(context.Background(), viewId, &getstream.DeleteFeedViewRequest{})

//        $this->feedsV3Client->deleteFeedView('viewID-123');

await _feedsV3Client.DeleteFeedViewAsync("viewID-123");

# self.client.feeds.delete_feed_view("viewID-123")

Intro & Defaults

Aggregation