Wait for operations

Required API Key: any key with the addObject ACL

Method signature

$index->saveObject(...)->wait();
$index->saveObjects(...)->wait();
$index->partialUpdateObject(...)->wait();
$index->partialUpdateObjects(...)->wait();
$index->replaceAllObjects(...)->wait();
$index->deleteObject(...)->wait();
$index->deleteObjects(...)->wait();
$index->deleteBy(...)->wait();
$index->clearObjects(...)->wait();
$index->batch(...)->wait();

$index->setSettings(...)->wait();

$index->saveSynonym(...)->wait();
$index->saveSynonyms(...)->wait();
$index->replaceAllSynonyms(...)->wait();
$index->deleteSynonym(...)->wait();
$index->clearSynonyms(...)->wait();

$index->saveRule(...)->wait();
$index->saveRules(...)->wait();
$index->replaceAllRules(...)->wait();
$index->deleteRule(...)->wait();
$index->clearRules(...)->wait();


$client->moveIndex(...)->wait();
$client->copyIndex(...)->wait();
$client->copyRules(...)->wait();
$client->copySynonyms(...)->wait();
$client->copySettings(...)->wait();

$client->addApiKey(...)->wait();
$client->updateApiKey(...)->wait();
$client->deleteApiKey(...)->wait();
$client->multipleBatch(...)->wait();

response.wait()

index.save_object!(...)
index.save_objects!(...)
index.partial_update_object!(...)
index.partial_update_objects!(...)
index.replace_all_objects!(...)
index.delete_object!(...)
index.delete_objects!(...)
index.delete_by!(...)
index.clear_objects!(...)
index.batch!(...)

index.set_settings!(...)

index.save_synonym!(...)
index.save_synonyms!(...)
index.replace_all_synonyms!(...)
index.delete_synonym!(...)
index.clear_synonyms!(...)

index.save_rule!(...)
index.save_rules!(...)
index.replace_all_rules!(...)
index.delete_rule!(...)
index.clear_rules!(...)


client.move_index!(...)
client.copy_index!(...)
client.copy_rules!(...)
client.copy_synonyms!(...)
client.copy_settings!(...)

client.add_api_key!(...)
client.update_api_key!(...)
client.delete_api_key!(...)
client.multiple_batch!(...)

index.saveObject(...).wait().then(response => {
  console.log(response);
});
index.saveObjects(...).wait().then(response => {
  console.log(response);
});
index.partialUpdateObject(...).wait().then(response => {
  console.log(response);
});
index.partialUpdateObjects(...).wait().then(response => {
  console.log(response);
});
index.replaceAllObjects(...).wait().then(response => {
  console.log(response);
});
index.deleteObject(...).wait().then(response => {
  console.log(response);
});
index.deleteObjects(...).wait().then(response => {
  console.log(response);
});
index.deleteBy(...).wait().then(response => {
  console.log(response);
});
index.clearObjects(...).wait().then(response => {
  console.log(response);
});
index.batch(...).wait().then(response => {
  console.log(response);
});

index.setSettings(...).wait().then(response => {
  console.log(response);
});

index.saveSynonym(...).wait().then(response => {
  console.log(response);
});
index.saveSynonyms(...).wait().then(response => {
  console.log(response);
});
index.replaceAllSynonyms(...).wait().then(response => {
  console.log(response);
});
index.deleteSynonym(...).wait().then(response => {
  console.log(response);
});
index.clearSynonyms(...).wait().then(response => {
  console.log(response);
});

index.saveRule(...).wait().then(response => {
  console.log(response);
});
index.saveRules(...).wait().then(response => {
  console.log(response);
});
index.replaceAllRules(...).wait().then(response => {
  console.log(response);
});
index.deleteRule(...).wait().then(response => {
  console.log(response);
});
index.clearRules(...).wait().then(response => {
  console.log(response);
});

client.moveIndex(...).wait().then(response => {
  console.log(response);
});
client.copyIndex(...).wait().then(response => {
  console.log(response);
});
client.copyRules(...).wait().then(response => {
  console.log(response);
});
client.copySynonyms(...).wait().then(response => {
  console.log(response);
});
client.copySettings(...).wait().then(response => {
  console.log(response);
});

client.addApiKey(...).wait().then(response => {
  console.log(response);
});
client.updateApiKey(...).wait().then(response => {
  console.log(response);
});
client.deleteApiKey(...).wait().then(response => {
  console.log(response);
});
client.multipleBatch(...).wait().then(response => {
  console.log(response);
});

index.save_object(...).wait()
index.save_objects(...).wait()
index.partial_update_object(...).wait()
index.partial_update_objects(...).wait()
index.replace_all_objects(...).wait()
index.delete_object(...).wait()
index.delete_objects(...).wait()
index.delete_by(...).wait()
index.clear_objects(...).wait()
index.batch(...).wait()

index.set_settings(...).wait()

index.save_synonym(...).wait()
index.save_synonyms(...).wait()
index.replace_all_synonyms(...).wait()
index.delete_synonym(...).wait()
index.clear_synonyms(...).wait()

index.save_rule(...).wait()
index.save_rules(...).wait()
index.replace_all_rules(...).wait()
index.delete_rule(...).wait()
index.clear_rules(...).wait()


client.move_index(...).wait()
client.copy_index(...).wait()
client.copy_rules(...).wait()
client.copy_synonyms(...).wait()
client.copy_settings(...).wait()

client.add_api_key(...).wait()
client.update_api_key(...).wait()
client.delete_api_key(...).wait()
client.multiple_batch(...).wait()

WaitableWrapper.wait(
  timeout: TimeInterval? = nil,
  requestOptions: RequestOptions? = nil,
  completion: (Result<Empty, Swift.Error>) -> Void
)

suspend fun waitTask(
    taskID: TaskID,
    timeout: Long? = null,
    requestOptions: RequestOptions? = null
): TaskStatus

suspend fun Task.wait(
    timeout: Long? = null,
    requestOptions: RequestOptions? = null
): TaskStatus

suspend fun List<Task>.wait(
    timeout: Long? = null,
    requestOptions: RequestOptions? = null
): List<TaskStatus>

index.SaveObject(...).Wait();
index.SaveObjects(...).Wait();
index.PartialUpdateObject(...).Wait();
index.PartialUpdateObjects(...).Wait();
index.ReplaceAllObjects(...).Wait();
index.DeleteObject(...).Wait();
index.DeleteObjects(...).Wait();
index.DeleteBy(...).Wait();
index.ClearObjects(...).Wait();
index.Batch(...).Wait();

index.SetSettings(...).Wait();

index.SaveSynonym(...).Wait();
index.SaveSynonyms(...).Wait();
index.ReplaceAllSynonyms(...).Wait();
index.DeleteSynonym(...).Wait();
index.ClearSynonyms(...).Wait();

index.SaveRule(...).Wait();
index.SaveRules(...).Wait();
index.ReplaceAllRules(...).Wait();
index.DeleteRule(...).Wait();
index.ClearRules(...).Wait();


client.MoveIndex(...).Wait();
client.CopyIndex(...).Wait();
client.CopyRules(...).Wait();
client.CopySynonyms(...).Wait();
client.CopySettings(...).Wait();

client.AddApiKey(...).Wait();
client.UpdateApiKey(...).Wait();
client.DeleteApiKey(...).Wait();
client.MultipleBatch(...).Wait();

index.saveObject(...).waitTask();
index.saveObjects(...).waitTask();
index.partialUpdateObject(...).waitTask();
index.partialUpdateObjects(...).waitTask();
index.replaceAllObjects(...).waitTask();
index.deleteObject(...).waitTask();
index.deleteObjects(...).waitTask();
index.deleteBy(...).waitTask();
index.clearObjects(...).waitTask();

index.setSettings(...).waitTask();

index.saveSynonym(...).waitTask();
index.saveSynonyms(...).waitTask();
index.replaceAllSynonyms(...).waitTask();
index.deleteSynonym(...).waitTask();
index.clearSynonyms(...).waitTask();

index.saveRule(...).waitTask();
index.saveRules(...).waitTask();
index.replaceAllRules(...).waitTask();
index.deleteRule(...).waitTask();
index.clearRules(...).waitTask();


client.moveIndex(...).waitTask();
client.copyIndex(...).waitTask();
client.copyRules(...).waitTask();
client.copySynonyms(...).waitTask();
client.copySettings(...).waitTask();

client.addApiKey(...).waitTask();
client.updateApiKey(...).waitTask();
client.deleteApiKey(...).waitTask();
client.multipleBatch(...).waitTask();

index.WaitTask(int taskID)

waitFor task taskID from "indexName"
waitFor task taskID from "indexName" options requestOptions

See code examples

You’re currently reading the JavaScript API client v4 documentation. Check the migration guide to learn how to upgrade from v3 to v4. You can still access the v3 documentation.

You’re currently reading the Ruby API client v2 documentation. Check the migration guide to learn how to upgrade from v1 to v2. You can still access the v1 documentation.

About this method

Wait for a task to complete to ensure synchronized index updates.

All Algolia write operations are asynchronous. When you make a request for a write operation, for example, to add or update records in your index, Algolia creates a task on a queue and returns a taskID. The task itself runs separately, depending on the server load. You can wait for a write operation to complete by using the task’s taskID and the waitTask method.

Examples

Read the Algolia CLI documentation for more information.

Wait until a new object is added to an index

Copy

1
2
3
4
5
6
$index->addObject(
  [
    'firstname' => 'Jimmie',
    'lastname'  => 'Barninger'
  ]
)->wait();

1
2
3
4
5
6
# Asynchronous call and wait until complete
response = index.add_object({ firstname: 'Jimmie', lastname: 'Barninger' })
response.wait

# Synchronous call, that handles the wait internally
index.add_object!({ firstname: 'Jimmie', lastname: 'Barninger' })

1
2
3
4
5
6
7
8
9
10
11
const object = {
  firstname: 'Jimmie',
  lastname: 'Barninger'
};

index
  .saveObject(object, { autoGenerateObjectIDIfNotExist: true })
  .wait()
  .then(({ objectID }) => {
    console.log(objectID);
  });

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
struct Contact: Codable {
  let firstName: String
  let lastName: String
}

let object = Contact(firstName: "Jimmie",
                     lastName: "Barninger")

try index.saveObject(object, autoGeneratingObjectID: true) { result in
    if case .success(let waitableWrapper) = result {
      waitableWrapper.wait() { result in
        if case .success(let response) = result {
          print("New object is indexed")
        }
      }
    }
}

1
2
3
4
5
6
7
8
9
10
11
Contact contact = new Contact
{
  Firstname = "Jimmie",
  Lastname = "Barninger"
};

index.SaveObject(contact, autoGenerateObjectId: true).Wait();

// Asynchronous
var resp = await index.SaveObjectsAsync(contacts, autoGenerateObjectId: true);
resp.Wait();

1
2
3
4
5
6
7
BatchIndexingResponse resp = index.saveObject(
  new Contact().setFirstname("Jimmie").setLastname("Barninger")
);

// All objects implementing the AlgoliaWaitableResponse interface
// Can be awaited with the .waitTask() method
resp.waitTask();

1
2
3
4
5
6
7
8
9
10
11
12
type Contact struct {
    Firstname string `json:"firstname"`
    Lastname  string `json:"lastname"`
}

contact := Contact{
    Firstname: "Jimmie",
    Lastname:  "Barninger",
}

res, err := index.SaveObject(contact, opt.AutoGenerateObjectIDIfNotExist(true))
err = res.Wait()

If you want to ensure multiple objects have been indexed, you must check all taskIDs.

Wait for indexing of a new object and send extra http header

Copy

1
2
3
4
5
6
7
8
$index->addObject(
  [
    'firstname' => 'Jimmie',
    'lastname'  => 'Barninger'
  ]
)->wait([
  'X-Forwarded-For' => '94.228.178.246'
]);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
const object = {
  firstname: 'Jimmie',
  lastname: 'Barninger'
};

const waitRequestOptions = {
  headers: {
    'X-Forwarded-For': '94.228.178.246'
  }
};

index
  .saveObject(object, { autoGenerateObjectIDIfNotExist: true })
  .wait(waitRequestOptions)
  .then(({ objectID }) => {
    console.log(objectID);
  });

1
2
3
4
5
6
index.save_object({
    'firstname': 'Jimmie',
    'lastname': 'Barninger'
}, {'autoGenerateObjectIDIfNotExist': True}).wait({
    'X-Forwarded-For': '94.228.178.246'
})

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
struct Contact: Codable {
  let firstName: String
  let lastName: String
}

let object = Contact(firstName: "Jimmie",
                     lastName: "Barninger")

var requestOptions = RequestOptions()
requestOptions.headers = ["X-Algolia-User-ID": "user123"]

try index.saveObject(object, autoGeneratingObjectID: true) { result in
    if case .success(let waitableWrapper) = result {
      waitableWrapper.wait(requestOptions: requestOptions) { result in
        if case .success(let response) = result {
          print("New object is indexed")
        }
      }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
List<Contact> contacts = new List<Contact>
{
    new Contact
    {
      ObjectID = "myID1",
      Firstname = "Jimmie",
      Lastname = "Barninger"
    },
    new Contact
    {
      ObjectID = "myID2",
      Firstname = "Warren",
      Lastname = "Speach"
    }
};

RequestOptions requestOptions = new RequestOptions
{
    Headers = new Dictionary<string,string>{ { "X-Algolia-User-ID", "user123" } }
};

index.SaveObjects(contacts, requestOptions).Wait();

// Asynchronous
var resp = await index.SaveObjectsAsync(contacts, requestOptions);
resp.Wait();

1
2
3
4
5
6
7
8
BatchIndexingResponse resp = index.saveObject(
  new Contact().setFirstname("Jimmie").setLastname("Barninger"),
  new RequestOptions().addExtraHeader("X-Algolia-User-ID", "user123")
);

// All objects implementing the AlgoliaWaitableResponse interface
// Can be awaited with the .waitTask() method
resp.waitTask();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
type Contact struct {
    Firstname string `json:"firstname"`
    Lastname  string `json:"lastname"`
}

contact := Contact{
    Firstname: "Jimmie",
    Lastname:  "Barninger",
}

opts := []interface{}{
    opt.AutoGenerateObjectIDIfNotExist(true),
    opt.ExtraHeaders(map[string]string{"X-Algolia-User-ID": "userID2"}),
}

res, err := index.SaveObject(contact, opts...)
err = res.Wait()

1
2
3
4
5
6
7
8
for {
  t <- client.execute { index into "toto" `object` MyObject("test") }
  r <- client.execute {
    waitFor task t from "toto" options RequestOptions(
      extraHeaders = Some(Map("X-Algolia-User-ID" => "user123"))
    )
  }
} yield "indexing is done"

Parameters

`taskID`	type: string Required taskID of the indexing task to wait for.
`requestOptions`	type: list default: No requestOptions Optional A list of request options to send along with the query.

Response

This method doesn't return a response.

Did you find this page helpful?