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

About this method # A

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 tasks’s taskID' and the waitTask` method.

Examples # A

Wait until a new object is added to an index#

Copy

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
index.save_object({
      'firstname': 'Jimmie',
      'lastname': 'Barninger'
  }, {'autoGenerateObjectIDIfNotExist': True}).wait()

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
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 # A

Parameter	Description
`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 # A

This method doesn't return a response.

Did you find this page helpful?

Wait for operations

About this method # Found an issue? Edit this page A Edit this page

Examples # Found an issue? Edit this page A Edit this page

Wait until a new object is added to an index#

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

Parameters # Found an issue? Edit this page A Edit this page

Response # Found an issue? Edit this page A Edit this page

On this page

About this method # A

Examples # A

Parameters # A

Response # A