Update and insert (upsert) a composition

// Initialize the client
var client = new CompositionClient(
  new CompositionConfig("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY")
);

// Call the API
var response = await client.PutCompositionAsync(
  "my-external-provider-compo",
  new Composition
  {
    ObjectID = "my-external-provider-compo",
    Name = "my external provider composition",
    Behavior = new CompositionBehavior(
      new CompositionInjectionBehavior
      {
        Injection = new Injection
        {
          Main = new InjectionMain
          {
            Source = new InjectionMainSource(
              new InjectionMainExternalProviderSource
              {
                ExternalProvider = new InjectionMainExternalProvider
                {
                  Index = "products",
                  ConfigurationID = "my-rmn-connection",
                  ConfigurationParams = new Dictionary<string, object>
                  {
                    { "campaign_id", "summer-sale" },
                    { "customer_id", "customer-default" },
                  },
                  Params = new MainInjectionQueryParameters { Filters = "instock:true" },
                  Ordering = Enum.Parse<ExternalProviderOrdering>("ProviderDefined"),
                },
              }
            ),
          },
          InjectedItems = new List<InjectionInjectedItem>
          {
            new InjectionInjectedItem
            {
              Key = "sponsored",
              Source = new InjectedItemSource(
                new InjectedItemExternalProviderSource
                {
                  ExternalProvider = new InjectedItemExternalProvider
                  {
                    Index = "products",
                    ConfigurationID = "my-rmn-connection",
                    ConfigurationParams = new Dictionary<string, object>
                    {
                      { "campaign_id", "summer-sale" },
                    },
                  },
                }
              ),
              Position = 0,
              Length = 2,
            },
          },
        },
      }
    ),
  }
);

// print the response
Console.WriteLine(response);

// Initialize the client
final client = CompositionClient(
    appId: 'ALGOLIA_APPLICATION_ID', apiKey: 'ALGOLIA_API_KEY');

// Call the API
final response = await client.putComposition(
  compositionID: "my-external-provider-compo",
  composition: Composition(
    objectID: "my-external-provider-compo",
    name: "my external provider composition",
    behavior: CompositionInjectionBehavior(
      injection: Injection(
        main: InjectionMain(
          source: InjectionMainExternalProviderSource(
            externalProvider: InjectionMainExternalProvider(
              index: "products",
              configurationID: "my-rmn-connection",
              configurationParams: {
                'campaign_id': "summer-sale",
                'customer_id': "customer-default",
              },
              params: MainInjectionQueryParameters(
                filters: "instock:true",
              ),
              ordering: ExternalProviderOrdering.fromJson("providerDefined"),
            ),
          ),
        ),
        injectedItems: [
          InjectionInjectedItem(
            key: "sponsored",
            source: InjectedItemExternalProviderSource(
              externalProvider: InjectedItemExternalProvider(
                index: "products",
                configurationID: "my-rmn-connection",
                configurationParams: {
                  'campaign_id': "summer-sale",
                },
              ),
            ),
            position: 0,
            length: 2,
          ),
        ],
      ),
    ),
  ),
);

// print the response
print(response);

// Initialize the client
client, err := composition.NewClient("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY")
if err != nil {
  // The client can fail to initialize if you pass an invalid parameter.
  panic(err)
}

// Call the API
response, err := client.PutComposition(client.NewApiPutCompositionRequest(
  "my-external-provider-compo",
  composition.NewEmptyComposition().
    SetObjectID("my-external-provider-compo").
    SetName("my external provider composition").
    SetBehavior(composition.CompositionInjectionBehaviorAsCompositionBehavior(
      composition.NewEmptyCompositionInjectionBehavior().SetInjection(
        composition.NewEmptyInjection().SetMain(
          composition.NewEmptyInjectionMain().SetSource(composition.InjectionMainExternalProviderSourceAsInjectionMainSource(
            composition.NewEmptyInjectionMainExternalProviderSource().SetExternalProvider(
              composition.NewEmptyInjectionMainExternalProvider().
                SetIndex("products").
                SetConfigurationID("my-rmn-connection").
                SetConfigurationParams(map[string]any{"campaign_id": "summer-sale", "customer_id": "customer-default"}).
                SetParams(
                  composition.NewEmptyMainInjectionQueryParameters().
                    SetFilters("instock:true"),
                ).
                SetOrdering(composition.ExternalProviderOrdering("providerDefined")),
            ),
          ))).SetInjectedItems(
          []composition.InjectionInjectedItem{
            *composition.NewEmptyInjectionInjectedItem().SetKey("sponsored").SetSource(composition.InjectedItemExternalProviderSourceAsInjectedItemSource(
              composition.NewEmptyInjectedItemExternalProviderSource().SetExternalProvider(
                composition.NewEmptyInjectedItemExternalProvider().SetIndex("products").SetConfigurationID("my-rmn-connection").SetConfigurationParams(map[string]any{"campaign_id": "summer-sale"})))).SetPosition(0).SetLength(2),
          }),
      ))),
))
if err != nil {
  // handle the eventual error
  panic(err)
}


// print the response
print(response)

// Initialize the client
CompositionClient client = new CompositionClient("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY");

// Call the API
TaskIDResponse response = client.putComposition(
  "my-external-provider-compo",
  new Composition()
    .setObjectID("my-external-provider-compo")
    .setName("my external provider composition")
    .setBehavior(
      new CompositionInjectionBehavior().setInjection(
        new Injection()
          .setMain(
            new InjectionMain().setSource(
              new InjectionMainExternalProviderSource().setExternalProvider(
                new InjectionMainExternalProvider()
                  .setIndex("products")
                  .setConfigurationID("my-rmn-connection")
                  .setConfigurationParams(
                    new HashMap() {
                      {
                        put("campaign_id", "summer-sale");
                        put("customer_id", "customer-default");
                      }
                    }
                  )
                  .setParams(new MainInjectionQueryParameters().setFilters("instock:true"))
                  .setOrdering(ExternalProviderOrdering.PROVIDER_DEFINED)
              )
            )
          )
          .setInjectedItems(
            Arrays.asList(
              new InjectionInjectedItem()
                .setKey("sponsored")
                .setSource(
                  new InjectedItemExternalProviderSource().setExternalProvider(
                    new InjectedItemExternalProvider()
                      .setIndex("products")
                      .setConfigurationID("my-rmn-connection")
                      .setConfigurationParams(
                        new HashMap() {
                          {
                            put("campaign_id", "summer-sale");
                          }
                        }
                      )
                  )
                )
                .setPosition(0)
                .setLength(2)
            )
          )
      )
    )
);

// print the response
System.out.println(response);

// Initialize the client
const client = compositionClient('ALGOLIA_APPLICATION_ID', 'ALGOLIA_API_KEY');

// Call the API
const response = await client.putComposition({
  compositionID: 'my-external-provider-compo',
  composition: {
    objectID: 'my-external-provider-compo',
    name: 'my external provider composition',
    behavior: {
      injection: {
        main: {
          source: {
            externalProvider: {
              index: 'products',
              configurationID: 'my-rmn-connection',
              configurationParams: { campaign_id: 'summer-sale', customer_id: 'customer-default' },
              params: { filters: 'instock:true' },
              ordering: 'providerDefined',
            },
          },
        },
        injectedItems: [
          {
            key: 'sponsored',
            source: {
              externalProvider: {
                index: 'products',
                configurationID: 'my-rmn-connection',
                configurationParams: { campaign_id: 'summer-sale' },
              },
            },
            position: 0,
            length: 2,
          },
        ],
      },
    },
  },
});


// print the response
console.log(response);

// Initialize the client
val client = CompositionClient(appId = "ALGOLIA_APPLICATION_ID", apiKey = "ALGOLIA_API_KEY")

// Call the API
var response =
  client.putComposition(
    compositionID = "my-external-provider-compo",
    composition =
      Composition(
        objectID = "my-external-provider-compo",
        name = "my external provider composition",
        behavior =
          CompositionInjectionBehavior(
            injection =
              Injection(
                main =
                  InjectionMain(
                    source =
                      InjectionMainExternalProviderSource(
                        externalProvider =
                          InjectionMainExternalProvider(
                            index = "products",
                            configurationID = "my-rmn-connection",
                            configurationParams =
                              buildJsonObject {
                                put("campaign_id", JsonPrimitive("summer-sale"))
                                put("customer_id", JsonPrimitive("customer-default"))
                              },
                            params = MainInjectionQueryParameters(filters = "instock:true"),
                            ordering =
                              ExternalProviderOrdering.entries.first {
                                it.value == "providerDefined"
                              },
                          )
                      )
                  ),
                injectedItems =
                  listOf(
                    InjectionInjectedItem(
                      key = "sponsored",
                      source =
                        InjectedItemExternalProviderSource(
                          externalProvider =
                            InjectedItemExternalProvider(
                              index = "products",
                              configurationID = "my-rmn-connection",
                              configurationParams =
                                buildJsonObject {
                                  put("campaign_id", JsonPrimitive("summer-sale"))
                                },
                            )
                        ),
                      position = 0,
                      length = 2,
                    )
                  ),
              )
          ),
      ),
  )


// print the response
println(response)

// Initialize the client
$client = CompositionClient::create('ALGOLIA_APPLICATION_ID', 'ALGOLIA_API_KEY');

// Call the API
$response = $client->putComposition(
    'my-external-provider-compo',
    ['objectID' => 'my-external-provider-compo',
        'name' => 'my external provider composition',
        'behavior' => ['injection' => ['main' => ['source' => ['externalProvider' => ['index' => 'products',
            'configurationID' => 'my-rmn-connection',
            'configurationParams' => ['campaign_id' => 'summer-sale',
                'customer_id' => 'customer-default',
            ],
            'params' => ['filters' => 'instock:true',
            ],
            'ordering' => 'providerDefined',
        ],
        ],
        ],
            'injectedItems' => [
                ['key' => 'sponsored',
                    'source' => ['externalProvider' => ['index' => 'products',
                        'configurationID' => 'my-rmn-connection',
                        'configurationParams' => ['campaign_id' => 'summer-sale',
                        ],
                    ],
                    ],
                    'position' => 0,
                    'length' => 2,
                ],
            ],
        ],
        ],
    ],
);


// print the response
var_dump($response);

# Initialize the client
# In an asynchronous context, you can use CompositionClient instead, which exposes the exact same methods.
client = CompositionClientSync("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY")

# Call the API
response = client.put_composition(
    composition_id="my-external-provider-compo",
    composition={
        "objectID": "my-external-provider-compo",
        "name": "my external provider composition",
        "behavior": {
            "injection": {
                "main": {
                    "source": {
                        "externalProvider": {
                            "index": "products",
                            "configurationID": "my-rmn-connection",
                            "configurationParams": {
                                "campaign_id": "summer-sale",
                                "customer_id": "customer-default",
                            },
                            "params": {
                                "filters": "instock:true",
                            },
                            "ordering": "providerDefined",
                        },
                    },
                },
                "injectedItems": [
                    {
                        "key": "sponsored",
                        "source": {
                            "externalProvider": {
                                "index": "products",
                                "configurationID": "my-rmn-connection",
                                "configurationParams": {
                                    "campaign_id": "summer-sale",
                                },
                            },
                        },
                        "position": 0,
                        "length": 2,
                    },
                ],
            },
        },
    },
)


# print the response
print(response)

# Initialize the client
client = Algolia::CompositionClient.create("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY")

# Call the API
response = client.put_composition(
  "my-external-provider-compo",
  Algolia::Composition::Composition.new(
    algolia_object_id: "my-external-provider-compo",
    name: "my external provider composition",
    behavior: Algolia::Composition::CompositionInjectionBehavior.new(
      injection: Algolia::Composition::Injection.new(
        main: Algolia::Composition::InjectionMain.new(
          source: Algolia::Composition::InjectionMainExternalProviderSource.new(
            external_provider: Algolia::Composition::InjectionMainExternalProvider.new(
              index: "products",
              configuration_id: "my-rmn-connection",
              configuration_params: {campaign_id: "summer-sale", customer_id: "customer-default"},
              params: Algolia::Composition::MainInjectionQueryParameters.new(filters: "instock:true"),
              ordering: "providerDefined"
            )
          )
        ),
        injected_items: [
          Algolia::Composition::InjectionInjectedItem.new(
            key: "sponsored",
            source: Algolia::Composition::InjectedItemExternalProviderSource.new(
              external_provider: Algolia::Composition::InjectedItemExternalProvider.new(
                index: "products",
                configuration_id: "my-rmn-connection",
                configuration_params: {campaign_id: "summer-sale"}
              )
            ),
            position: 0,
            length: 2
          )
        ]
      )
    )
  )
)


# print the response
puts(response)

// Initialize the client
val client = CompositionClient(appId = "ALGOLIA_APPLICATION_ID", apiKey = "ALGOLIA_API_KEY")

// Call the API
val response = Await.result(
  client.putComposition(
    compositionID = "my-external-provider-compo",
    composition = Composition(
      objectID = "my-external-provider-compo",
      name = "my external provider composition",
      behavior = CompositionInjectionBehavior(
        injection = Injection(
          main = InjectionMain(
            source = Some(
              InjectionMainExternalProviderSource(
                externalProvider = InjectionMainExternalProvider(
                  index = "products",
                  configurationID = "my-rmn-connection",
                  configurationParams =
                    Some(Map("campaign_id" -> "summer-sale", "customer_id" -> "customer-default")),
                  params = Some(
                    MainInjectionQueryParameters(
                      filters = Some("instock:true")
                    )
                  ),
                  ordering = Some(ExternalProviderOrdering.withName("providerDefined"))
                )
              )
            )
          ),
          injectedItems = Some(
            Seq(
              InjectionInjectedItem(
                key = "sponsored",
                source = InjectedItemExternalProviderSource(
                  externalProvider = InjectedItemExternalProvider(
                    index = "products",
                    configurationID = "my-rmn-connection",
                    configurationParams = Some(Map("campaign_id" -> "summer-sale"))
                  )
                ),
                position = 0,
                length = 2
              )
            )
          )
        )
      )
    )
  ),
  Duration(100, "sec")
)

// print the response
println(response)

// Initialize the client
let client = try CompositionClient(appID: "ALGOLIA_APPLICATION_ID", apiKey: "ALGOLIA_API_KEY")

// Call the API
let response = try await client.putComposition(
    compositionID: "my-external-provider-compo",
    composition: Composition(
        objectID: "my-external-provider-compo",
        name: "my external provider composition",
        behavior: CompositionBehavior
            .compositionInjectionBehavior(CompositionInjectionBehavior(injection: Injection(
                main: InjectionMain(source: InjectionMainSource
                    .injectionMainExternalProviderSource(
                        InjectionMainExternalProviderSource(externalProvider: InjectionMainExternalProvider(
                            index: "products",
                            configurationID: "my-rmn-connection",
                            configurationParams: [
                                "campaign_id": AnyCodable("summer-sale"),
                                "customer_id": AnyCodable("customer-default"),
                            ],
                            ordering: ExternalProviderOrdering.providerDefined,
                            params: MainInjectionQueryParameters(filters: "instock:true")
                        ))
                    )),
                injectedItems: [InjectionInjectedItem(
                    key: "sponsored",
                    source: InjectedItemSource
                        .injectedItemExternalProviderSource(
                            InjectedItemExternalProviderSource(externalProvider: InjectedItemExternalProvider(
                                index: "products",
                                configurationID: "my-rmn-connection",
                                configurationParams: ["campaign_id": AnyCodable("summer-sale")]
                            ))
                        ),
                    position: 0,
                    length: 2
                )]
            )))
    )
)

// print the response
print(response)