References

When you add a user or a collection object to an activity, Stream stores the unique reference and replaces it at read time. In some complex cases, you need to be able to generate a reference to an existing object and embed that inside of an activity.

// First create a collection entry with upsert api
var collectionObj = new CollectionObject("cheese-burger");
collectionObj.SetData("name", "Cheese Burger");
await client.Collections.UpsertAsync("food", collectionObj);

// Then create a user
var userData = new Dictionary<string, object>
{
  {"name", "John Doe"},
  {"occupation", "Software Engineer"},
  {"gender", "male"},
};
var user = await client.Users.AddAsync("john-doe", userData);

// Since we know their IDs we can create references to both without reading from APIs
var cheeseBurgerRef = client.Collections.Ref("food", "cheese-burger");
var johnDoeRef = client.Users.Ref("john-doe");

// And then add an activity with these references
var activity = new Activity(johnDoeRef, "eat", cheeseBurgerRef);
await client.Feed("user", "john").AddActivityAsync(activity);

// First create a collection entry with upsert api
await client.collections.upsert('food', [
	{ id: 'cheese-burger', name: 'Cheese Burger' },
]);

// Then create a user
await client.user('john-doe').create({
	name: 'John Doe',
	occupation: 'Software Engineer',
	gender: 'male',
});

// Since we know their IDs we can create references to both without reading from APIs
const cheeseBurgerRef = client.collections.entry('food', 'cheese-burger');
const johnDoeRef = client.user('john-doe');

// And then add an activity with these references
await client.feed('user', 'john').addActivity({
	actor: johnDoeRef,
	verb: 'eat',
	object: cheeseBurgerRef,
});

# First create a collection entry with upsert api
client.collections.upsert(
  "food", [{"id": "cheese-burger", "name": "Cheese Burger"}]
)

# Then create a user
client.users.add(
  "john-doe",
  {"name": "John Doe", "occupation": "Software Engineer", "gender": "male"},
)

# Since we know their IDs we can create references to both without reading from APIs
cheese_burger_ref = client.collections.create_reference("food", "cheese-burger")
john_doe_ref = client.users.create_reference("john-doe")

# And then add an activity with these references
client.feed("user", "john").add_activity(
  {"actor": john_doe_ref, "verb": "eat", "object": cheese_burger_ref}
)

# First create a collection entry with upsert api
client.collections.upsert(
  "food", [{:id =&gt; "cheese-burger", :name =&gt; "Cheese Burger"}]
)

# Then create a user
client.users.add(
  "john-doe",
  :data =&gt; {:name =&gt; "John Doe", :occupation =&gt; "Software Engineer", :gender =&gt; "male"},
)

# Since we know their IDs we can create references to both without reading from APIs
cheese_burger_ref = client.collections.create_reference("food", "cheese-burger")
john_doe_ref = client.users.create_reference("john-doe")

# And then add an activity with these references
feed.add_activity(
  {:actor =&gt; john_doe_ref, :verb =&gt; "eat", :object =&gt; cheese_burger_ref}
)

# First create a collection entry with upsert api
$client->collections()->upsert(
  "food", ["id" => "cheese-burger", "name" => "Cheese Burger"]
);

# Then create a user
$client->users()->add(
  "john-doe",
  ["name" => "John Doe", "occupation" => "Software Engineer", "gender" => "male"],
  true
);

# Since we know their IDs we can create references to both without reading from APIs
$cheese_burger_ref = $client->collections()->createReference("food", "cheese-burger");
$john_doe_ref = $client->users()->createReference("john-doe");

# And then add an activity with these references
$feed->addActivity(
  ["actor" => $john_doe_ref, "verb" => "eat", "object" => $cheese_burger_ref]
);

// First create a collection entry with upsert api
client.collections().upsert("food", new CollectionData().set("name", "Cheese Burger")).join();

// Then create a user
client.user("john-doe").create(new Data()
    .set("name", "John Doe")
    .set("occupation", "Software Engineer")
    .set("gender", "male")).join();

// Since we know their IDs we can create references to both without reading from APIs
String cheeseBurgerRef = createCollectionReference("food", "cheese-burger");
String johnDoeRef = createUserReference("john-doe");

client.flatFeed("user", "john").addActivity(Activity.builder()
    .actor(johnDoeRef)
    .verb("eat")
    .object(cheeseBurgerRef)
    .build()).join();

// First create a collection entry with upsert api
	obj := stream.CollectionObject{
		ID: "cheese-burger",
		Data: map[string]any{
			"name": "Cheese Burger",
		},
	}
	_, err := client.Collections().Upsert(context.TODO(), "food", obj)
	if err != nil {
		panic(err)
	}

	// Then create a user
	user := stream.User{
		ID: "john-doe",
		Data: map[string]any{
			"name":    "John Doe",
			"occupation": "Software Engineer",
			"gender":   "male",
		},
	}
	_, err := client.Users().Add(context.TODO(), user, false)
	if err != nil {
		panic(err)
	}

	// Since we know their IDs we can create references to both without reading from APIs
	cheeseBurgerRef := client.Collections().CreateReference("food", "cheese-burger")
	johnDoeRef := client.Users().CreateReference("john-doe")

	// And then add an activity with these references
	activity := stream.Activity{
		Actor: johnDoeRef,
		Verb:  "eat",
		Object: cheeseBurgerRef,
	}
	_, err := userFeed.AddActivity(context.TODO(), activity)
	if err != nil {
		panic(err)
	}

// First create a collection entry with upsert api
let cheeseBurger = Food(name: "Cheese Burger", rating: 4, id: "cheese-burger")

client.add(collectionObject: cheeseBurger) { _ in
  // Then create a user
  let user = User(id: "john-doe")
  client.create(user: user) { _ in
    // Since we know their IDs we can create references to both without reading from APIs
    // The `CollectionObjectProtocol` and `UserProtocol` conformed to the `Enrichable` protocol.
    let cheeseBurgerRef = cheeseBurger.referenceId
    let johnDoeRef = user.referenceId
    
    client.flatFeed(feedSlug: "user", userId: "john")
       .add(Activity(actor: johnDoeRef, verb: "eat", object: cheeseBurgerRef)) { result in /* ... */ }
  }
}

// First create a collection entry with upsert api
await client.collections.upsert('food', [
 CollectionEntry(id: 'cheese-burger', data: {'name': 'Cheese Burger'}),
]);

// Then create a user
await client.user('john-doe').getOrCreate({
 'name': 'John Doe',
 'occupation': 'Software Engineer',
 'gender': 'male',
});

// Since we know their IDs we can create references to both without reading from APIs
final cheeseBurgerRef = client.collections.entry('food', 'cheese-burger').ref;
final johnDoeRef = client.user('john-doe').ref;

// And then add an activity with these references
await client.flatFeed('user', 'john').addActivity(Activity(
 actor: johnDoeRef,
 verb: 'eat',
 object: cheeseBurgerRef,
));

If you are using the APIs on web / mobile (see auth section) you must set activity.actor to the reference of the current user or otherwise you will get a permission error (see examples above).

Enrichment

Users