Class Analyzer
Accessors
name
- get name(): string
Name of this Analyzer.
+See also database.Database.
+Returns string
Methods
create
- create<Options>(options): Promise<Options extends CreateIdentityAnalyzerOptions
? IdentityAnalyzerDescription
: Options extends CreateDelimiterAnalyzerOptions
? DelimiterAnalyzerDescription
: Options extends CreateStemAnalyzerOptions
? StemAnalyzerDescription
: Options extends CreateNormAnalyzerOptions
? NormAnalyzerDescription
: Options extends CreateNgramAnalyzerOptions
? NgramAnalyzerDescription
: Options extends CreateTextAnalyzerOptions
? TextAnalyzerDescription
: Options extends CreateSegmentationAnalyzerOptions
? SegmentationAnalyzerDescription
: Options extends CreateAqlAnalyzerOptions
? AqlAnalyzerDescription
: Options extends CreatePipelineAnalyzerOptions
? PipelineAnalyzerDescription
: (...) extends (...)
? (...)
: (...)> Creates a new Analyzer with the given
+optionsand the instance's name.See also database.Database#createAnalyzer.
+Type Parameters
- Options extends CreateAnalyzerOptions
Parameters
- options: Options
Options for creating the Analyzer.
+
Returns Promise<Options extends CreateIdentityAnalyzerOptions
? IdentityAnalyzerDescription
: Options extends CreateDelimiterAnalyzerOptions
? DelimiterAnalyzerDescription
: Options extends CreateStemAnalyzerOptions
? StemAnalyzerDescription
: Options extends CreateNormAnalyzerOptions
? NormAnalyzerDescription
: Options extends CreateNgramAnalyzerOptions
? NgramAnalyzerDescription
: Options extends CreateTextAnalyzerOptions
? TextAnalyzerDescription
: Options extends CreateSegmentationAnalyzerOptions
? SegmentationAnalyzerDescription
: Options extends CreateAqlAnalyzerOptions
? AqlAnalyzerDescription
: Options extends CreatePipelineAnalyzerOptions
? PipelineAnalyzerDescription
: (...) extends (...)
? (...)
: (...)>Example
+const db = new Database();
const analyzer = db.analyzer("potatoes");
await analyzer.create({ type: "identity" });
// the identity Analyzer "potatoes" now exists +
drop
- drop(force?): Promise<ArangoApiResponse<{
name: string;
}>> Deletes the Analyzer from the database.
+Parameters
- force: boolean = false
Whether the Analyzer should still be deleted even if it +is currently in use.
+
Returns Promise<ArangoApiResponse<{
name: string;
}>>Example
+const db = new Database();
const analyzer = db.analyzer("some-analyzer");
await analyzer.drop();
// the Analyzer "some-analyzer" no longer exists +- force: boolean = false
exists
get
- get(): Promise<ArangoApiResponse<AnalyzerDescription>>
Retrieves the Analyzer definition for the Analyzer.
+Returns Promise<ArangoApiResponse<AnalyzerDescription>>
Example
+const db = new Database();
const analyzer = db.analyzer("some-analyzer");
const definition = await analyzer.get();
// definition contains the Analyzer definition +
Class ArrayCursor<T>
The ArrayCursor type represents a cursor returned from a
+database.Database#query.
When using TypeScript, cursors can be cast to a specific item type in order +to increase type safety.
+See also BatchedArrayCursor.
+Example
const db = new Database();
const query = aql`FOR x IN 1..5 RETURN x`;
const result = await db.query(query) as ArrayCursor<number>;
+Example
const db = new Database();
const query = aql`FOR x IN 1..10 RETURN x`;
const cursor = await db.query(query);
for await (const value of cursor) {
// Process each value asynchronously
await processValue(value);
}
+Type Parameters
Accessors
batches
- get batches(): BatchedArrayCursor<T>
A BatchedArrayCursor providing batch-wise access to the cursor +result set.
+See also BatchedArrayCursor#items.
+Returns BatchedArrayCursor<T>
count
- get count(): undefined | number
Total number of documents in the query result. Only available if the +
+countoption was used.Returns undefined | number
extra
- get extra(): CursorExtras
Additional information about the cursor.
+Returns CursorExtras
has
- get hasNext(): boolean
Whether the cursor has more values. If set to
+false, the cursor has +already been depleted and contains no more items.Returns boolean
Methods
[async
- [async
Iterator](): AsyncGenerator<T, undefined, undefined> Enables use with
+for awaitto deplete the cursor by asynchronously +yielding every value in the cursor's remaining result set.Note: If the result set spans multiple batches, any remaining batches +will only be fetched on demand. Depending on the cursor's TTL and the +processing speed, this may result in the server discarding the cursor +before it is fully depleted.
+Returns AsyncGenerator<T, undefined, undefined>
Example
+const cursor = await db.query(aql`
FOR user IN users
FILTER user.isActive
RETURN user
`);
for await (const user of cursor) {
console.log(user.email, user.isAdmin);
} +
all
- all(): Promise<T[]>
Depletes the cursor, then returns an array containing all values in the +cursor's remaining result list.
+Returns Promise<T[]>
Example
+const cursor = await db.query(aql`FOR x IN 1..5 RETURN x`);
const result = await cursor.all(); // [1, 2, 3, 4, 5]
console.log(cursor.hasNext); // false +
flat
- flat
Map<R>(callback): Promise<R[]> Depletes the cursor by applying the
+callbackfunction to each item in +the cursor's remaining result list. Returns an array containing the +return values ofcallbackfor each item, flattened to a depth of 1.Note: If the result set spans multiple batches, any remaining batches +will only be fetched on demand. Depending on the cursor's TTL and the +processing speed, this may result in the server discarding the cursor +before it is fully depleted.
+See also: +
+Array.prototype.flatMap.Type Parameters
Parameters
Returns Promise<R[]>
Example
+const cursor = await db.query(aql`FOR x IN 1..5 RETURN x`);
const squares = await cursor.flatMap((currentValue) => {
return [currentValue, currentValue ** 2];
});
console.log(squares); // [1, 1, 2, 4, 3, 9, 4, 16, 5, 25]
console.log(cursor.hasNext); // false +Example
+const cursor = await db.query(aql`FOR x IN 1..5 RETURN x`);
const odds = await cursor.flatMap((currentValue) => {
if (currentValue % 2 === 0) {
return []; // empty array flattens into nothing
}
return currentValue; // or [currentValue]
});
console.logs(odds); // [1, 3, 5] +
for
- for
Each(callback): Promise<boolean> Advances the cursor by applying the
+callbackfunction to each item in +the cursor's remaining result list until the cursor is depleted or +callbackreturns the exact valuefalse. Returns a promise that +evalues totrueunless the function returnedfalse.Note: If the result set spans multiple batches, any remaining batches +will only be fetched on demand. Depending on the cursor's TTL and the +processing speed, this may result in the server discarding the cursor +before it is fully depleted.
+See also: +
+Array.prototype.forEach.Parameters
- callback: ((currentValue, index, self) => false | void)
Function to execute on each element.
+- (currentValue, index, self): false | void
Parameters
- currentValue: T
- index: number
- self: this
Returns false | void
Returns Promise<boolean>
Example
+const cursor = await db.query(aql`FOR x IN 1..5 RETURN x`);
const result = await cursor.forEach((currentValue) => {
console.log(currentValue);
});
console.log(result) // true
console.log(cursor.hasNext); // false +Example
+const cursor = await db.query(aql`FOR x IN 1..5 RETURN x`);
const result = await cursor.forEach((currentValue) => {
console.log(currentValue);
return false; // stop after the first item
});
console.log(result); // false
console.log(cursor.hasNext); // true +- callback: ((currentValue, index, self) => false | void)
kill
- kill(): Promise<void>
Kills the cursor and frees up associated database resources.
+This method has no effect if all batches have already been fetched.
+Returns Promise<void>
Example
+const cursor1 = await db.query(aql`FOR x IN 1..5 RETURN x`);
console.log(cursor1.hasMore); // false
await cursor1.kill(); // no effect
const cursor2 = await db.query(
aql`FOR x IN 1..5 RETURN x`,
{ batchSize: 2 }
);
console.log(cursor2.hasMore); // true
await cursor2.kill(); // cursor is depleted +
map
- map<R>(callback): Promise<R[]>
Depletes the cursor by applying the
+callbackfunction to each item in +the cursor's remaining result list. Returns an array containing the +return values ofcallbackfor each item.Note: This creates an array of all return values, which may impact +memory use when working with very large query result sets. Consider using +ArrayCursor#forEach, ArrayCursor#reduce or +ArrayCursor#flatMap instead.
+See also: +
+Array.prototype.map.Type Parameters
Parameters
Returns Promise<R[]>
Example
+const cursor = await db.query(aql`FOR x IN 1..5 RETURN x`);
const squares = await cursor.map((currentValue) => {
return currentValue ** 2;
});
console.log(squares); // [1, 4, 9, 16, 25]
console.log(cursor.hasNext); // false +
next
- next(): Promise<undefined | T>
Advances the cursor and returns the next value in the cursor's remaining +result list, or
+undefinedif the cursor has been depleted.Note: If the result set spans multiple batches, any remaining batches +will only be fetched on demand. Depending on the cursor's TTL and the +processing speed, this may result in the server discarding the cursor +before it is fully depleted.
+Returns Promise<undefined | T>
Example
+const cursor = await db.query(aql`FOR x IN 1..3 RETURN x`);
const one = await cursor.next(); // 1
const two = await cursor.next(); // 2
const three = await cursor.next(); // 3
const empty = await cursor.next(); // undefined +
reduce
- reduce<R>(reducer, initialValue): Promise<R>
Depletes the cursor by applying the
+reducerfunction to each item in +the cursor's remaining result list. Returns the return value ofreducer+for the last item.Note: Most complex uses of the
+reducemethod can be replaced with +simpler code using ArrayCursor#forEach or thefor awaitsyntax.Note: If the result set spans multiple batches, any remaining batches +will only be fetched on demand. Depending on the cursor's TTL and the +processing speed, this may result in the server discarding the cursor +before it is fully depleted.
+See also: +
+Array.prototype.reduce.Type Parameters
Parameters
Returns Promise<R>
Example
+function largestOfTwo(one, two) {
return Math.max(one, two);
}
const cursor = await db.query(aql`FOR x IN 1..5 RETURN x`);
const result = await cursor.reduce(largestOfTwo, 0);
console.log(result); // 5
console.log(cursor.hasNext); // false
const emptyResult = await cursor.reduce(largestOfTwo, 0);
console.log(emptyResult); // 0 +Example
+// BAD! NEEDLESSLY COMPLEX!
const cursor = await db.query(aql`FOR x IN 1..5 RETURN x`);
const result = await cursor.reduce((accumulator, currentValue) => {
if (currentValue % 2 === 0) {
accumulator.even.push(...currentValue);
} else {
accumulator.odd.push(...currentValue);
}
return accumulator;
}, { odd: [], even: [] });
console.log(result); // { odd: [1, 3, 5], even: [2, 4] }
// GOOD! MUCH SIMPLER!
const cursor = await db.query(aql`FOR x IN 1..5 RETURN x`);
const odd = [];
const even = [];
for await (const currentValue of cursor) {
if (currentValue % 2 === 0) {
even.push(currentValue);
} else {
odd.push(currentValue);
}
}
console.log({ odd, even }); // { odd: [1, 3, 5], even: [2, 4] } +- reduce<R>(reducer): Promise<undefined | R>
Depletes the cursor by applying the
+reducerfunction to each item in +the cursor's remaining result list. Returns the return value ofreducer+for the last item.Note: If the result set spans multiple batches, any remaining batches +will only be fetched on demand. Depending on the cursor's TTL and the +processing speed, this may result in the server discarding the cursor +before it is fully depleted.
+See also: +
+Array.prototype.reduce.Type Parameters
Parameters
Returns Promise<undefined | R>
Example
+function largestOfTwo(one, two) {
return Math.max(one, two);
}
const cursor = await db.query(aql`FOR x IN 1..5 RETURN x`);
const result = await cursor.reduce(largestOfTwo);
console.log(result); // 5
console.log(cursor.hasNext); // false
const emptyResult = await cursor.reduce(largestOfTwo);
console.log(emptyResult); // undefined +
Class BatchedArrayCursor<T>
The BatchedArrayCursor provides a batch-wise API to an ArrayCursor.
When using TypeScript, cursors can be cast to a specific item type in order +to increase type safety.
+Example
const db = new Database();
const query = aql`FOR x IN 1..5 RETURN x`;
const cursor = await db.query(query) as ArrayCursor<number>;
const batches = cursor.batches;
+Example
const db = new Database();
const query = aql`FOR x IN 1..10000 RETURN x`;
const cursor = await db.query(query, { batchSize: 10 });
for await (const batch of cursor.batches) {
// Process all values in a batch in parallel
await Promise.all(batch.map(
value => asyncProcessValue(value)
));
}
+Type Parameters
Accessors
count
- get count(): undefined | number
Total number of documents in the query result. Only available if the +
+countoption was used.Returns undefined | number
extra
- get extra(): Readonly<CursorExtras>
Additional information about the cursor.
+Returns Readonly<CursorExtras>
has
- get hasMore(): boolean
Whether the cursor has any remaining batches that haven't yet been +fetched. If set to
+false, all batches have been fetched and no +additional requests to the server will be made when consuming any +remaining batches from this cursor.Returns boolean
has
- get hasNext(): boolean
Whether the cursor has more batches. If set to
+false, the cursor has +already been depleted and contains no more batches.Returns boolean
items
- get items(): ArrayCursor<T>
An ArrayCursor providing item-wise access to the cursor result set.
+See also ArrayCursor#batches.
+Returns ArrayCursor<T>
Methods
[async
- [async
Iterator](): AsyncGenerator<T[], undefined, undefined> Enables use with
+for awaitto deplete the cursor by asynchronously +yielding every batch in the cursor's remaining result set.Note: If the result set spans multiple batches, any remaining batches +will only be fetched on demand. Depending on the cursor's TTL and the +processing speed, this may result in the server discarding the cursor +before it is fully depleted.
+Returns AsyncGenerator<T[], undefined, undefined>
Example
+const cursor = await db.query(aql`
FOR user IN users
FILTER user.isActive
RETURN user
`);
for await (const users of cursor.batches) {
for (const user of users) {
console.log(user.email, user.isAdmin);
}
} +
all
- all(): Promise<T[][]>
Depletes the cursor, then returns an array containing all batches in the +cursor's remaining result list.
+Returns Promise<T[][]>
Example
+const cursor = await db.query(
aql`FOR x IN 1..5 RETURN x`,
{ batchSize: 2 }
);
const result = await cursor.batches.all(); // [[1, 2], [3, 4], [5]]
console.log(cursor.hasNext); // false +
flat
- flat
Map<R>(callback): Promise<R[]> Depletes the cursor by applying the
+callbackfunction to each batch in +the cursor's remaining result list. Returns an array containing the +return values ofcallbackfor each batch, flattened to a depth of 1.Note: If the result set spans multiple batches, any remaining batches +will only be fetched on demand. Depending on the cursor's TTL and the +processing speed, this may result in the server discarding the cursor +before it is fully depleted.
+See also: +
+Array.prototype.flatMap.Type Parameters
Parameters
Returns Promise<R[]>
Example
+const cursor = await db.query(
aql`FOR x IN 1..5 RETURN x`,
{ batchSize: 2 }
);
const squares = await cursor.batches.flatMap((currentBatch) => {
return currentBatch.map((value) => value ** 2);
});
console.log(squares); // [1, 1, 2, 4, 3, 9, 4, 16, 5, 25]
console.log(cursor.hasNext); // false +Example
+const cursor = await db.query(
aql`FOR x IN 1..5 RETURN x`,
{ batchSize: 1 }
);
const odds = await cursor.batches.flatMap((currentBatch) => {
if (currentBatch[0] % 2 === 0) {
return []; // empty array flattens into nothing
}
return currentBatch;
});
console.logs(odds); // [1, 3, 5] +
for
- for
Each(callback): Promise<boolean> Advances the cursor by applying the
+callbackfunction to each item in +the cursor's remaining result list until the cursor is depleted or +callbackreturns the exact valuefalse. Returns a promise that +evalues totrueunless the function returnedfalse.Note: If the result set spans multiple batches, any remaining batches +will only be fetched on demand. Depending on the cursor's TTL and the +processing speed, this may result in the server discarding the cursor +before it is fully depleted.
+See also: +
+Array.prototype.forEach.Parameters
- callback: ((currentBatch, index, self) => false | void)
Function to execute on each element.
+- (currentBatch, index, self): false | void
Parameters
- currentBatch: T[]
- index: number
- self: this
Returns false | void
Returns Promise<boolean>
Example
+const cursor = await db.query(
aql`FOR x IN 1..5 RETURN x`,
{ batchSize: 2 }
);
const result = await cursor.batches.forEach((currentBatch) => {
for (const value of currentBatch) {
console.log(value);
}
});
console.log(result) // true
console.log(cursor.hasNext); // false +Example
+const cursor = await db.query(
aql`FOR x IN 1..5 RETURN x`,
{ batchSize: 2 }
);
const result = await cursor.batches.forEach((currentBatch) => {
for (const value of currentBatch) {
console.log(value);
}
return false; // stop after the first batch
});
console.log(result); // false
console.log(cursor.hasNext); // true +- callback: ((currentBatch, index, self) => false | void)
kill
- kill(): Promise<void>
Drains the cursor and frees up associated database resources.
+This method has no effect if all batches have already been consumed.
+Returns Promise<void>
Example
+const cursor1 = await db.query(aql`FOR x IN 1..5 RETURN x`);
console.log(cursor1.hasMore); // false
await cursor1.kill(); // no effect
const cursor2 = await db.query(
aql`FOR x IN 1..5 RETURN x`,
{ batchSize: 2 }
);
console.log(cursor2.hasMore); // true
await cursor2.kill(); // cursor is depleted +
load
- load
All(): Promise<void> Loads all remaining batches from the server.
+Warning: This may impact memory use when working with very large +query result sets.
+Returns Promise<void>
Example
+const cursor = await db.query(
aql`FOR x IN 1..5 RETURN x`,
{ batchSize: 1 }
);
console.log(cursor.hasMore); // true
await cursor.batches.loadAll();
console.log(cursor.hasMore); // false
console.log(cursor.hasNext); // true
for await (const item of cursor) {
console.log(item);
// No server roundtrips necessary any more
} +
map
- map<R>(callback): Promise<R[]>
Depletes the cursor by applying the
+callbackfunction to each batch in +the cursor's remaining result list. Returns an array containing the +return values ofcallbackfor each batch.Note: This creates an array of all return values, which may impact +memory use when working with very large query result sets. Consider using +BatchedArrayCursor#forEach, BatchedArrayCursor#reduce or +BatchedArrayCursor#flatMap instead.
+See also: +
+Array.prototype.map.Type Parameters
Parameters
Returns Promise<R[]>
Example
+const cursor = await db.query(
aql`FOR x IN 1..5 RETURN x`,
{ batchSize: 2 }
);
const squares = await cursor.batches.map((currentBatch) => {
return currentBatch.map((value) => value ** 2);
});
console.log(squares); // [[1, 4], [9, 16], [25]]
console.log(cursor.hasNext); // false +
next
- next(): Promise<undefined | T[]>
Advances the cursor and returns all remaining values in the cursor's +current batch. If the current batch has already been exhausted, fetches +the next batch from the server and returns it, or
+undefinedif the +cursor has been depleted.Note: If the result set spans multiple batches, any remaining batches +will only be fetched on demand. Depending on the cursor's TTL and the +processing speed, this may result in the server discarding the cursor +before it is fully depleted.
+Returns Promise<undefined | T[]>
Example
+const cursor = await db.query(
aql`FOR i IN 1..10 RETURN i`,
{ batchSize: 5 }
);
const firstBatch = await cursor.batches.next(); // [1, 2, 3, 4, 5]
await cursor.next(); // 6
const lastBatch = await cursor.batches.next(); // [7, 8, 9, 10]
console.log(cursor.hasNext); // false +
reduce
- reduce<R>(reducer, initialValue): Promise<R>
Depletes the cursor by applying the
+reducerfunction to each batch in +the cursor's remaining result list. Returns the return value ofreducer+for the last batch.Note: Most complex uses of the
+reducemethod can be replaced with +simpler code using BatchedArrayCursor#forEach or thefor await+syntax.Note: If the result set spans multiple batches, any remaining batches +will only be fetched on demand. Depending on the cursor's TTL and the +processing speed, this may result in the server discarding the cursor +before it is fully depleted.
+See also: +
+Array.prototype.reduce.Type Parameters
Parameters
Returns Promise<R>
Example
+function largestValue(baseline, values) {
return Math.max(baseline, ...values);
}
const cursor = await db.query(
aql`FOR x IN 1..5 RETURN x`,
{ batchSize: 3 }
);
const result = await cursor.batches.reduce(largestValue, 0);
console.log(result); // 5
console.log(cursor.hasNext); // false
const emptyResult = await cursor.batches.reduce(largestValue, 0);
console.log(emptyResult); // 0 +Example
+// BAD! NEEDLESSLY COMPLEX!
const cursor = await db.query(
aql`FOR x IN 1..5 RETURN x`,
{ batchSize: 1 }
);
const result = await cursor.reduce((accumulator, currentBatch) => {
if (currentBatch[0] % 2 === 0) {
accumulator.even.push(...currentBatch);
} else {
accumulator.odd.push(...currentBatch);
}
return accumulator;
}, { odd: [], even: [] });
console.log(result); // { odd: [1, 3, 5], even: [2, 4] }
// GOOD! MUCH SIMPLER!
const cursor = await db.query(aql`FOR x IN 1..5 RETURN x`);
const odd = [];
const even = [];
for await (const currentBatch of cursor) {
if (currentBatch[0] % 2 === 0) {
even.push(...currentBatch);
} else {
odd.push(...currentBatch);
}
}
console.log({ odd, even }); // { odd: [1, 3, 5], even: [2, 4] } +- reduce<R>(reducer): Promise<undefined | R>
Depletes the cursor by applying the
+reducerfunction to each batch in +the cursor's remaining result list. Returns the return value ofreducer+for the last batch.Note: If the result set spans multiple batches, any remaining batches +will only be fetched on demand. Depending on the cursor's TTL and the +processing speed, this may result in the server discarding the cursor +before it is fully depleted.
+See also: +
+Array.prototype.reduce.Type Parameters
Parameters
Returns Promise<undefined | R>
Example
+function largestValue(values1, values2) {
return [Math.max(...values1, ...values2)];
}
const cursor = await db.query(
aql`FOR x IN 1..5 RETURN x`,
{ batchSize: 3 }
);
const result = await cursor.batches.reduce(largestValue);
console.log(result); // [5]
console.log(cursor.hasNext); // false +
Class Database
An object representing a single ArangoDB database. All arangojs collections,
+cursors, analyzers and so on are linked to a Database object.
Index
Constructors
Accessors
Methods
Constructors
constructor
- new
Database(config?): Database Creates a new
+Databaseinstance with its own connection pool.See also Database#database.
+Parameters
Optionalconfig: ConfigAn object with configuration options.
+
Returns Database
Example
+const db = new Database({
url: "http://127.0.0.1:8529",
databaseName: "my_database",
auth: { username: "admin", password: "hunter2" },
}); +- new
Database(url, name?): Database Creates a new
+Databaseinstance with its own connection pool.See also Database#database.
+Parameters
- url: string | string[]
Base URL of the ArangoDB server or list of server URLs. +Equivalent to the
+urloption in connection.Config. Optionalname: string
Returns Database
Example
+const db = new Database("http://127.0.0.1:8529", "my_database");
db.useBasicAuth("admin", "hunter2"); +- url: string | string[]
Accessors
name
- get name(): string
Name of the ArangoDB database this instance represents.
+Returns string
queue
- get queueTime(): QueueTimeMetrics
Methods for accessing the server-reported queue times of the mostly +recently received responses.
+Returns QueueTimeMetrics
Methods
acquire
- acquire
Host List(overwrite?): Promise<void> Updates the URL list by requesting a list of all coordinators in the +cluster and adding any endpoints not initially specified in the +connection.Config.
+For long-running processes communicating with an ArangoDB cluster it is +recommended to run this method periodically (e.g. once per hour) to make +sure new coordinators are picked up correctly and can be used for +fail-over or load balancing.
+Parameters
- overwrite: boolean = false
If set to
+true, the existing host list will be +replaced instead of extended.
Returns Promise<void>
Example
+const db = new Database();
const interval = setInterval(
() => db.acquireHostList(),
5 * 60 * 1000 // every 5 minutes
);
// later
clearInterval(interval);
system.close(); +- overwrite: boolean = false
analyzer
- analyzer(analyzerName): Analyzer
Returns an analyzer.Analyzer instance representing the Analyzer with the +given
+analyzerName.Parameters
- analyzerName: string
Returns Analyzer
Example
+const db = new Database();
const analyzer = db.analyzer("some-analyzer");
const info = await analyzer.get(); +
analyzers
- analyzers(): Promise<Analyzer[]>
Fetches all Analyzers visible in the database and returns an array of +analyzer.Analyzer instances for those Analyzers.
+See also Database#listAnalyzers.
+Returns Promise<Analyzer[]>
Example
+const db = new Database();
const analyzers = await db.analyzers();
// analyzers is an array of Analyzer instances +
begin
- begin
Transaction(collections, options?): Promise<Transaction> Begins a new streaming transaction for the given collections, then returns +a transaction.Transaction instance for the transaction.
+Collections can be specified as collection names (strings) or objects +implementing the collection.ArangoCollection interface:
+Collection, +graph.GraphVertexCollection, graph.GraphEdgeCollection as +well as (in TypeScript) collection.DocumentCollection and +collection.EdgeCollection.Parameters
- collections: TransactionCollections
Collections involved in the transaction.
+ Optionaloptions: TransactionOptionsOptions for the transaction.
+
Returns Promise<Transaction>
Example
+const vertices = db.collection("vertices");
const edges = db.collection("edges");
const trx = await db.beginTransaction({
read: ["vertices"],
write: [edges] // collection instances can be passed directly
});
const start = await trx.step(() => vertices.document("a"));
const end = await trx.step(() => vertices.document("b"));
await trx.step(() => edges.save({ _from: start._id, _to: end._id }));
await trx.commit(); +- collections: TransactionCollections
- begin
Transaction(collections, options?): Promise<Transaction> Begins a new streaming transaction for the given collections, then returns +a transaction.Transaction instance for the transaction.
+Collections can be specified as collection names (strings) or objects +implementing the collection.ArangoCollection interface:
+Collection, +graph.GraphVertexCollection, graph.GraphEdgeCollection as well as +(in TypeScript) collection.DocumentCollection and collection.EdgeCollection.Parameters
- collections: (string | ArangoCollection)[]
Collections that can be read from and written to +during the transaction.
+ Optionaloptions: TransactionOptionsOptions for the transaction.
+
Returns Promise<Transaction>
Example
+const vertices = db.collection("vertices");
const edges = db.collection("edges");
const trx = await db.beginTransaction([
"vertices",
edges // collection instances can be passed directly
]);
const start = await trx.step(() => vertices.document("a"));
const end = await trx.step(() => vertices.document("b"));
await trx.step(() => edges.save({ _from: start._id, _to: end._id }));
await trx.commit(); +- collections: (string | ArangoCollection)[]
- begin
Transaction(collection, options?): Promise<Transaction> Begins a new streaming transaction for the given collections, then returns +a transaction.Transaction instance for the transaction.
+The Collection can be specified as a collection name (string) or an object +implementing the collection.ArangoCollection interface:
+Collection, +graph.GraphVertexCollection, graph.GraphEdgeCollection as well as +(in TypeScript) collection.DocumentCollection and collection.EdgeCollection.Parameters
- collection: string | ArangoCollection
A collection that can be read from and written to +during the transaction.
+ Optionaloptions: TransactionOptionsOptions for the transaction.
+
Returns Promise<Transaction>
Example
+const vertices = db.collection("vertices");
const start = vertices.document("a");
const end = vertices.document("b");
const edges = db.collection("edges");
const trx = await db.beginTransaction(
edges // collection instances can be passed directly
);
await trx.step(() => edges.save({ _from: start._id, _to: end._id }));
await trx.commit(); +- collection: string | ArangoCollection
clear
- clear
Slow Queries(): Promise<void> Clears the list of recent slow queries.
+See also Database#listSlowQueries.
+Returns Promise<void>
Example
+const db = new Database();
await db.clearSlowQueries();
// Slow query list is now cleared +
clear
- clear
User Access Level(username, __namedParameters): Promise<ArangoApiResponse<Record<string, AccessLevel>>> Clears the given ArangoDB user's access level for the database, or the +given collection in the given database.
+Parameters
- username: string
Name of the ArangoDB user to clear the access level for.
+ - __namedParameters: UserAccessLevelOptions
Returns Promise<ArangoApiResponse<Record<string, AccessLevel>>>
Example
+const db = new Database();
await db.clearUserAccessLevel("steve");
// The access level of the user "steve" has been cleared for the current
// database. +Example
+const db = new Database();
await db.clearUserAccessLevel("steve", { database: "staging" });
// The access level of the user "steve" has been cleared for the "staging"
// database. +Example
+const db = new Database();
await db.clearUserAccessLevel("steve", { collection: "pokemons" });
// The access level of the user "steve" has been cleared for the
// "pokemons" collection in the current database. +Example
+const db = new Database();
await db.clearUserAccessLevel("steve", {
database: "staging",
collection: "pokemons"
});
// The access level of the user "steve" has been cleared for the
// "pokemons" collection in the "staging" database. +Example
+const db = new Database();
const staging = db.database("staging");
await db.clearUserAccessLevel("steve", { database: staging });
// The access level of the user "steve" has been cleared for the "staging"
// database. +Example
+const db = new Database();
const staging = db.database("staging");
await db.clearUserAccessLevel("steve", {
collection: staging.collection("pokemons")
});
// The access level of the user "steve" has been cleared for the
// "pokemons" collection in database "staging". +- username: string
close
- close(): void
Closes all active connections of this database instance.
+Can be used to clean up idling connections during longer periods of +inactivity.
+Note: This method currently has no effect in the browser version of +arangojs.
+Returns void
Example
+const db = new Database();
const sessions = db.collection("sessions");
// Clean up expired sessions once per hour
setInterval(async () => {
await db.query(aql`
FOR session IN ${sessions}
FILTER session.expires < DATE_NOW()
REMOVE session IN ${sessions}
`);
// Making sure to close the connections because they're no longer used
system.close();
}, 1000 * 60 * 60); +
collection
- collection<T>(collectionName): DocumentCollection<T, T> & EdgeCollection<T, T>
Returns a
+Collectioninstance for the given collection name.In TypeScript the collection implements both the +collection.DocumentCollection and collection.EdgeCollection +interfaces and can be cast to either type to enforce a stricter API.
+Type Parameters
Parameters
- collectionName: string
Name of the edge collection.
+
Returns DocumentCollection<T, T> & EdgeCollection<T, T>
Example
+const db = new Database();
const collection = db.collection("potatoes"); +Example
+interface Person {
name: string;
}
const db = new Database();
const persons = db.collection<Person>("persons"); +Example
+interface Person {
name: string;
}
interface Friend {
startDate: number;
endDate?: number;
}
const db = new Database();
const documents = db.collection("persons") as DocumentCollection<Person>;
const edges = db.collection("friends") as EdgeCollection<Friend>; +- collectionName: string
collections
- collections(excludeSystem?): Promise<(DocumentCollection<any, any> & EdgeCollection<any, any>)[]>
Fetches all collections from the database and returns an array of +
+Collectioninstances.In TypeScript these instances implement both the +collection.DocumentCollection and collection.EdgeCollection +interfaces and can be cast to either type to enforce a stricter API.
+See also Database#listCollections.
+Parameters
- excludeSystem: boolean = true
Whether system collections should be excluded.
+
Returns Promise<(DocumentCollection<any, any> & EdgeCollection<any, any>)[]>
Example
+const db = new Database();
const collections = await db.collections();
// collections is an array of DocumentCollection and EdgeCollection
// instances not including system collections +Example
+const db = new Database();
const collections = await db.collections(false);
// collections is an array of DocumentCollection and EdgeCollection
// instances including system collections +- excludeSystem: boolean = true
commit
- commit
Local Service State(replace?): Promise<void> Writes all locally available services to the database and updates any +service bundles missing in the database.
+Parameters
- replace: boolean = false
If set to
+true, outdated services will also be +committed. This can be used to solve some consistency problems when +service bundles are missing in the database or were deleted manually.
Returns Promise<void>
Example
+await db.commitLocalServiceState();
// all services available on the coordinator have been written to the db +Example
+await db.commitLocalServiceState(true);
// all service conflicts have been resolved in favor of this coordinator +- replace: boolean = false
compute
- compute
Cluster Rebalance(opts): Promise<ClusterRebalanceResult> Computes a set of move shard operations to rebalance the cluster.
+Parameters
- opts: ClusterRebalanceOptions
Returns Promise<ClusterRebalanceResult>
Example
+const db = new Database();
const result = await db.computerClusterRebalance({
moveLeaders: true,
moveFollowers: true
});
if (result.moves.length) {
await db.executeClusterRebalance(result.moves);
} +
create
- create
Analyzer(analyzerName, options): Promise<Analyzer> Creates a new Analyzer with the given
+analyzerNameandoptions, then +returns an analyzer.Analyzer instance for the new Analyzer.Parameters
- analyzerName: string
Name of the Analyzer.
+ - options: CreateAnalyzerOptions
An object defining the properties of the Analyzer.
+
Returns Promise<Analyzer>
Example
+const db = new Database();
const analyzer = await db.createAnalyzer("potatoes", { type: "identity" });
// the identity Analyzer "potatoes" now exists +- analyzerName: string
create
- create
Collection<T>(collectionName, options?): Promise<DocumentCollection<T, T>> Creates a new collection with the given
+collectionNameandoptions, +then returns a collection.DocumentCollection instance for the new collection.Type Parameters
Parameters
- collectionName: string
Name of the new collection.
+ Optionaloptions: CreateCollectionOptions & {
type?: DOCUMENT_COLLECTION;
}Options for creating the collection.
+
Returns Promise<DocumentCollection<T, T>>
Example
+const db = new Database();
const documents = db.createCollection("persons"); +Example
+interface Person {
name: string;
}
const db = new Database();
const documents = db.createCollection<Person>("persons"); +- collectionName: string
- create
Collection<T>(collectionName, options): Promise<EdgeCollection<T, T>> Creates a new edge collection with the given
+collectionNameand +options, then returns an collection.EdgeCollection instance for the new +edge collection.Type Parameters
Parameters
- collectionName: string
Name of the new collection.
+ - options: CreateCollectionOptions & {
type: EDGE_COLLECTION;
}Options for creating the collection.
+
Returns Promise<EdgeCollection<T, T>>
Example
+const db = new Database();
const edges = db.createCollection("friends", {
type: CollectionType.EDGE_COLLECTION
}); +Example
+interface Friend {
startDate: number;
endDate?: number;
}
const db = new Database();
const edges = db.createCollection<Friend>("friends", {
type: CollectionType.EDGE_COLLECTION
}); +- collectionName: string
create
- create
Database(databaseName, options?): Promise<Database> Creates a new database with the given
+databaseNamewith the given +optionsand returns aDatabaseinstance for that database.Parameters
- databaseName: string
Name of the database to create.
+ Optionaloptions: CreateDatabaseOptionsOptions for creating the database.
+
Returns Promise<Database>
Example
+const db = new Database();
const info = await db.createDatabase("mydb", {
users: [{ username: "root" }]
});
// the database has been created +- databaseName: string
- create
Database(databaseName, users): Promise<Database> Creates a new database with the given
+databaseNamewith the given +usersand returns aDatabaseinstance for that database.Parameters
- databaseName: string
Name of the database to create.
+ - users: CreateDatabaseUser[]
Database users to create with the database.
+
Returns Promise<Database>
Example
+const db = new Database();
const info = await db.createDatabase("mydb", [{ username: "root" }]);
// the database has been created +- databaseName: string
create
- create
Edge Collection<T>(collectionName, options?): Promise<EdgeCollection<T, T>> Creates a new edge collection with the given
+collectionNameand +options, then returns an collection.EdgeCollection instance for the new +edge collection.This is a convenience method for calling Database#createCollection +with
+options.typeset toEDGE_COLLECTION.Type Parameters
Parameters
- collectionName: string
Name of the new collection.
+ Optionaloptions: CreateCollectionOptionsOptions for creating the collection.
+
Returns Promise<EdgeCollection<T, T>>
Example
+const db = new Database();
const edges = db.createEdgeCollection("friends"); +Example
+interface Friend {
startDate: number;
endDate?: number;
}
const db = new Database();
const edges = db.createEdgeCollection<Friend>("friends"); +- collectionName: string
create
- create
Function(name, code, isDeterministic?): Promise<ArangoApiResponse<{
isNewlyCreated: boolean;
}>> Creates an AQL user function with the given name and code if it does +not already exist or replaces it if a function with the same name already +existed.
+Parameters
- name: string
A valid AQL function name. The function name must consist +of at least two alphanumeric identifiers separated with double colons.
+ - code: string
A string evaluating to a JavaScript function (not a +JavaScript function object).
+ - isDeterministic: boolean = false
If set to
+true, the function is expected to +always return the same result for equivalent inputs. This option currently +has no effect but may allow for optimizations in the future.
Returns Promise<ArangoApiResponse<{
isNewlyCreated: boolean;
}>>Example
+const db = new Database();
await db.createFunction(
"ACME::ACCOUNTING::CALCULATE_VAT",
"(price) => price * 0.19"
);
// Use the new function in an AQL query with template handler:
const cursor = await db.query(aql`
FOR product IN products
RETURN MERGE(
{ vat: ACME::ACCOUNTING::CALCULATE_VAT(product.price) },
product
)
`);
// cursor is a cursor for the query result +- name: string
create
- create
Graph(graphName, edgeDefinitions, options?): Promise<Graph> Creates a graph with the given
+graphNameandedgeDefinitions, then +returns a graph.Graph instance for the new graph.Parameters
- graphName: string
Name of the graph to be created.
+ - edgeDefinitions: EdgeDefinitionOptions[]
An array of edge definitions.
+ Optionaloptions: CreateGraphOptionsAn object defining the properties of the graph.
+
Returns Promise<Graph>
- graphName: string
create
- create
Hot Backup(options?): Promise<HotBackupResult> (Enterprise Edition only.) Creates a hot backup of the entire ArangoDB +deployment including all databases, collections, etc.
+Returns an object describing the backup result.
+Parameters
- options: HotBackupOptions = {}
Options for creating the backup.
+
Returns Promise<HotBackupResult>
Example
+const info = await db.createHotBackup();
// a hot backup has been created +- options: HotBackupOptions = {}
create
- create
Job<T>(callback): Promise<Job<T>> Creates an async job by executing the given callback function. The first +database request performed by the callback will be marked for asynchronous +execution and its result will be made available as an async job.
+Returns a Job instance that can be used to retrieve the result +of the callback function once the request has been executed.
+Type Parameters
Parameters
Returns Promise<Job<T>>
Example
+const db = new Database();
const job = await db.createJob(() => db.collections());
while (!job.isLoaded) {
await timeout(1000);
await job.load();
}
// job.result is a list of Collection instances +
create
- create
User(username, passwd): Promise<ArangoApiResponse<ArangoUser>> Creates a new ArangoDB user with the given password.
+Parameters
- username: string
Name of the ArangoDB user to create.
+ - passwd: string
Password of the new ArangoDB user.
+
Returns Promise<ArangoApiResponse<ArangoUser>>
Example
+const db = new Database();
const user = await db.createUser("steve", "hunter2");
// The user "steve" has been created +- username: string
- create
User(username, options): Promise<ArangoApiResponse<ArangoUser>> Creates a new ArangoDB user with the given options.
+Parameters
- username: string
Name of the ArangoDB user to create.
+ - options: UserOptions
Additional options for creating the ArangoDB user.
+
Returns Promise<ArangoApiResponse<ArangoUser>>
Example
+const db = new Database();
const user = await db.createUser("steve", { passwd: "hunter2" });
// The user "steve" has been created +- username: string
create
- create
View(viewName, options): Promise<View> Creates a new View with the given
+viewNameandoptions, then returns a +view.View instance for the new View.Parameters
- viewName: string
Name of the View.
+ - options: CreateViewOptions
An object defining the properties of the View.
+
Returns Promise<View>
Example
+const db = new Database();
const view = await db.createView("potatoes", { type: "arangosearch" });
// the ArangoSearch View "potatoes" now exists +- viewName: string
database
- database(databaseName): Database
Creates a new
+Databaseinstance for the givendatabaseNamethat +shares this database's connection pool.See also :constructor.
+Parameters
- databaseName: string
Name of the database.
+
Returns Database
Example
+const systemDb = new Database();
const myDb = system.database("my_database"); +- databaseName: string
databases
- databases(): Promise<Database[]>
Fetches all databases from the server and returns an array of
+Database+instances for those databases.See also Database#listDatabases and +Database#userDatabases.
+Returns Promise<Database[]>
Example
+const db = new Database();
const names = await db.databases();
// databases is an array of databases +
delete
delete
- delete
Expired Job Results(threshold): Promise<void> Deletes the results of all completed async jobs created before the given +threshold.
+Parameters
- threshold: number
The expiration timestamp in milliseconds.
+
Returns Promise<void>
Example
+const db = new Database();
const ONE_WEEK = 7 * 24 * 60 * 60 * 1000;
await db.deleteExpiredJobResults(Date.now() - ONE_WEEK);
// all job results older than a week have been deleted +- threshold: number
delete
download
- download
Service(mount): Promise<Buffer | Blob> Retrieves a zip bundle containing the service files.
+Returns a
+Bufferin node.js orBlobin the browser.Parameters
- mount: string
The service's mount point, relative to the database.
+
Returns Promise<Buffer | Blob>
Example
+const db = new Database();
const serviceBundle = await db.downloadService("/my-foxx"); +- mount: string
drop
- drop
Database(databaseName): Promise<boolean> Deletes the database with the given
+databaseNamefrom the server.Parameters
- databaseName: string
Name of the database to delete.
+
Returns Promise<boolean>
Example
+const db = new Database();
await db.dropDatabase("mydb");
// database "mydb" no longer exists +- databaseName: string
drop
- drop
Function(name, group?): Promise<ArangoApiResponse<{
deletedCount: number;
}>> Deletes the AQL user function with the given name from the database.
+Parameters
- name: string
The name of the user function to drop.
+ - group: boolean = false
If set to
+true, all functions with a name starting with +namewill be deleted, otherwise only the function with the exact name +will be deleted.
Returns Promise<ArangoApiResponse<{
deletedCount: number;
}>>Example
+const db = new Database();
await db.dropFunction("ACME::ACCOUNTING::CALCULATE_VAT");
// the function no longer exists +- name: string
execute
- execute
Cluster Rebalance(moves): Promise<unknown> Executes the given cluster move shard operations.
+Parameters
- moves: ClusterRebalanceMove[]
Returns Promise<unknown>
Example
+const db = new Database();
const result = await db.computerClusterRebalance({
moveLeaders: true,
moveFollowers: true
});
if (result.moves.length) {
await db.executeClusterRebalance(result.moves);
} +
execute
- execute
Transaction(collections, action, options?): Promise<any> Performs a server-side JavaScript transaction and returns its return +value.
+Collections can be specified as collection names (strings) or objects +implementing the collection.ArangoCollection interface:
+Collection, +graph.GraphVertexCollection, graph.GraphEdgeCollection as well as +(in TypeScript) collection.DocumentCollection and collection.EdgeCollection.Note: The
+actionfunction will be evaluated and executed on the +server inside ArangoDB's embedded JavaScript environment and can not +access any values other than those passed via theparamsoption.See the official ArangoDB documentation for +the JavaScript
+@arangodbmodule +for information about accessing the database from within ArangoDB's +server-side JavaScript environment.Parameters
- collections: TransactionCollections & {
allowImplicit?: boolean;
}Collections involved in the transaction.
+ - action: string
A string evaluating to a JavaScript function to be +executed on the server.
+ Optionaloptions: TransactionOptions & {
params?: any;
}Options for the transaction. If
+options.allowImplicit+is specified, it will be used ifcollections.allowImplicitwas not +specified.
Returns Promise<any>
Example
+const db = new Database();
const action = `
function(params) {
// This code will be executed inside ArangoDB!
const { query } = require("@arangodb");
return query\`
FOR user IN _users
FILTER user.age > ${params.age}
RETURN u.user
\`.toArray();
}
`);
const result = await db.executeTransaction({
read: ["_users"]
}, action, {
params: { age: 12 }
});
// result contains the return value of the action +- collections: TransactionCollections & {
- execute
Transaction(collections, action, options?): Promise<any> Performs a server-side transaction and returns its return value.
+Collections can be specified as collection names (strings) or objects +implementing the collection.ArangoCollection interface:
+Collection, +graph.GraphVertexCollection, graph.GraphEdgeCollection as well as +(in TypeScript) collection.DocumentCollection and collection.EdgeCollection.Note: The
+actionfunction will be evaluated and executed on the +server inside ArangoDB's embedded JavaScript environment and can not +access any values other than those passed via theparamsoption. +See the official ArangoDB documentation for +the JavaScript@arangodbmodule +for information about accessing the database from within ArangoDB's +server-side JavaScript environment.Parameters
- collections: (string | ArangoCollection)[]
Collections that can be read from and written to +during the transaction.
+ - action: string
A string evaluating to a JavaScript function to be +executed on the server.
+ Optionaloptions: TransactionOptions & {
params?: any;
}Options for the transaction.
+
Returns Promise<any>
Example
+const db = new Database();
const action = `
function(params) {
// This code will be executed inside ArangoDB!
const { query } = require("@arangodb");
return query\`
FOR user IN _users
FILTER user.age > ${params.age}
RETURN u.user
\`.toArray();
}
`);
const result = await db.executeTransaction(["_users"], action, {
params: { age: 12 }
});
// result contains the return value of the action +- collections: (string | ArangoCollection)[]
- execute
Transaction(collection, action, options?): Promise<any> Performs a server-side transaction and returns its return value.
+The Collection can be specified as a collection name (string) or an object +implementing the collection.ArangoCollection interface:
+Collection, +graph.GraphVertexCollection, graph.GraphEdgeCollection as well as +(in TypeScript) collection.DocumentCollection and collection.EdgeCollection.Note: The
+actionfunction will be evaluated and executed on the +server inside ArangoDB's embedded JavaScript environment and can not +access any values other than those passed via theparamsoption. +See the official ArangoDB documentation for +the JavaScript@arangodbmodule +for information about accessing the database from within ArangoDB's +server-side JavaScript environment.Parameters
- collection: string | ArangoCollection
A collection that can be read from and written to +during the transaction.
+ - action: string
A string evaluating to a JavaScript function to be +executed on the server.
+ Optionaloptions: TransactionOptions & {
params?: any;
}Options for the transaction.
+
Returns Promise<any>
Example
+const db = new Database();
const action = `
function(params) {
// This code will be executed inside ArangoDB!
const { query } = require("@arangodb");
return query\`
FOR user IN _users
FILTER user.age > ${params.age}
RETURN u.user
\`.toArray();
}
`);
const result = await db.executeTransaction("_users", action, {
params: { age: 12 }
});
// result contains the return value of the action +- collection: string | ArangoCollection
exists
explain
- explain(query, options?): Promise<ArangoApiResponse<SingleExplainResult>>
Explains a database query using the given
+query.See the aql!aql template string handler for information about how +to create a query string without manually defining bind parameters nor +having to worry about escaping variables.
+Parameters
- query: AqlQuery<any>
An object containing an AQL query string and bind +parameters, e.g. the object returned from an aql!aql template string.
+ Optionaloptions: ExplainOptions & {
allPlans?: false;
}Options for explaining the query.
+
Returns Promise<ArangoApiResponse<SingleExplainResult>>
Example
+const db = new Database();
const collection = db.collection("some-collection");
const explanation = await db.explain(aql`
FOR doc IN ${collection}
FILTER doc.flavor == "strawberry"
RETURN doc._key
`); +- query: AqlQuery<any>
- explain(query, options?): Promise<ArangoApiResponse<MultiExplainResult>>
Explains a database query using the given
+query.See the aql!aql template string handler for information about how +to create a query string without manually defining bind parameters nor +having to worry about escaping variables.
+Parameters
- query: AqlQuery<any>
An object containing an AQL query string and bind +parameters, e.g. the object returned from an aql!aql template string.
+ Optionaloptions: ExplainOptions & {
allPlans: true;
}Options for explaining the query.
+
Returns Promise<ArangoApiResponse<MultiExplainResult>>
Example
+const db = new Database();
const collection = db.collection("some-collection");
const explanation = await db.explain(
aql`
FOR doc IN ${collection}
FILTER doc.flavor == "strawberry"
RETURN doc._key
`,
{ allPlans: true }
); +- query: AqlQuery<any>
- explain(query, bindVars?, options?): Promise<ArangoApiResponse<SingleExplainResult>>
Explains a database query using the given
+queryandbindVars.See the aql!aql template string handler for a safer and easier +alternative to passing strings directly.
+Parameters
- query: string | AqlLiteral
An AQL query string.
+ OptionalbindVars: Record<string, any>An object defining bind parameters for the query.
+Optionaloptions: ExplainOptions & {
allPlans?: false;
}Options for explaining the query.
+
Returns Promise<ArangoApiResponse<SingleExplainResult>>
Example
+const db = new Database();
const collection = db.collection("some-collection");
const explanation = await db.explain(
`
FOR doc IN @@collection
FILTER doc.flavor == "strawberry"
RETURN doc._key
`,
{ "@collection": collection.name }
); +- query: string | AqlLiteral
- explain(query, bindVars?, options?): Promise<ArangoApiResponse<MultiExplainResult>>
Explains a database query using the given
+queryandbindVars.See the aql!aql template string handler for a safer and easier +alternative to passing strings directly.
+Parameters
- query: string | AqlLiteral
An AQL query string.
+ OptionalbindVars: Record<string, any>An object defining bind parameters for the query.
+Optionaloptions: ExplainOptions & {
allPlans: true;
}Options for explaining the query.
+
Returns Promise<ArangoApiResponse<MultiExplainResult>>
Example
+const db = new Database();
const collection = db.collection("some-collection");
const explanation = await db.explain(
`
FOR doc IN @@collection
FILTER doc.flavor == "strawberry"
RETURN doc._key
`,
{ "@collection": collection.name },
{ allPlans: true }
); +- query: string | AqlLiteral
get
- get(): Promise<DatabaseInfo>
Fetches the database description for the active database from the server.
+Returns Promise<DatabaseInfo>
Example
+const db = new Database();
const info = await db.get();
// the database exists +
get
- get
Cluster Imbalance(): Promise<ClusterRebalanceState> Computes the current cluster imbalance.
+Returns Promise<ClusterRebalanceState>
Example
+const db = new Database();
const imbalance = await db.getClusterImbalance(); +
get
- get
Log Entries(options?): Promise<LogEntries> Retrieves the log messages from the server's global log.
+Parameters
Optionaloptions: LogEntriesOptionsOptions for retrieving the log entries.
+
Returns Promise<LogEntries>
Example
+const log = await db.getLogEntries();
for (let i = 0; i < log.totalAmount; i++) {
console.log(`${
new Date(log.timestamp[i] * 1000).toISOString()
} - [${LogLevel[log.level[i]]}] ${log.text[i]} (#${log.lid[i]})`);
} +
get
- get
Log Level(): Promise<Record<string, LogLevelSetting>> Retrieves the server's current log level for each topic.
+Returns Promise<Record<string, LogLevelSetting>>
Example
+const levels = await db.getLogLevel();
console.log(levels.request); // log level for incoming requests +
get
- get
Log Messages(options?): Promise<LogMessage[]> Retrieves the log messages from the server's global log.
+Parameters
Optionaloptions: LogEntriesOptionsOptions for retrieving the log entries.
+
Returns Promise<LogMessage[]>
Deprecated
This endpoint has been deprecated in ArangoDB 3.8. +Use Database#getLogEntries instead.
+Example
+const messages = await db.getLogMessages();
for (const m of messages) {
console.log(`${m.date} - [${m.level}] ${m.message} (#${m.id})`);
} +
get
- get
Service(mount): Promise<ServiceInfo> Retrieves information about a mounted service.
+Parameters
- mount: string
The service's mount point, relative to the database.
+
Returns Promise<ServiceInfo>
Example
+const db = new Database();
const info = await db.getService("/my-service");
// info contains detailed information about the service +- mount: string
get
- get
Service Configuration(mount, minimal?): Promise<Record<string, ServiceConfiguration>> Retrieves information about the service's configuration options and their +current values.
+See also Database#replaceServiceConfiguration and +Database#updateServiceConfiguration.
+Parameters
- mount: string
The service's mount point, relative to the database.
+ Optionalminimal: falseIf set to
+true, the result will only include each +configuration option's current value. Otherwise it will include the full +definition for each option.
Returns Promise<Record<string, ServiceConfiguration>>
Example
+const db = new Database();
const config = await db.getServiceConfiguration("/my-service");
for (const [key, option] of Object.entries(config)) {
console.log(`${option.title} (${key}): ${option.current}`);
} +- mount: string
- get
Service Configuration(mount, minimal): Promise<Record<string, any>> Retrieves information about the service's configuration options and their +current values.
+See also Database#replaceServiceConfiguration and +Database#updateServiceConfiguration.
+Parameters
- mount: string
The service's mount point, relative to the database.
+ - minimal: true
If set to
+true, the result will only include each +configuration option's current value. Otherwise it will include the full +definition for each option.
Returns Promise<Record<string, any>>
Example
+const db = new Database();
const config = await db.getServiceConfiguration("/my-service", true);
for (const [key, value] of Object.entries(config)) {
console.log(`${key}: ${value}`);
} +- mount: string
get
- get
Service Dependencies(mount, minimal?): Promise<Record<string, SingleServiceDependency | MultiServiceDependency>> Retrieves information about the service's dependencies and their current +mount points.
+See also Database#replaceServiceDependencies and +Database#updateServiceDependencies.
+Parameters
- mount: string
The service's mount point, relative to the database.
+ Optionalminimal: falseIf set to
+true, the result will only include each +dependency's current mount point. Otherwise it will include the full +definition for each dependency.
Returns Promise<Record<string, SingleServiceDependency | MultiServiceDependency>>
Example
+const db = new Database();
const deps = await db.getServiceDependencies("/my-service");
for (const [key, dep] of Object.entries(deps)) {
console.log(`${dep.title} (${key}): ${dep.current}`);
} +- mount: string
- get
Service Dependencies(mount, minimal): Promise<Record<string, string | string[]>> Retrieves information about the service's dependencies and their current +mount points.
+See also Database#replaceServiceDependencies and +Database#updateServiceDependencies.
+Parameters
- mount: string
The service's mount point, relative to the database.
+ - minimal: true
If set to
+true, the result will only include each +dependency's current mount point. Otherwise it will include the full +definition for each dependency.
Returns Promise<Record<string, string | string[]>>
Example
+const db = new Database();
const deps = await db.getServiceDependencies("/my-service", true);
for (const [key, value] of Object.entries(deps)) {
console.log(`${key}: ${value}`);
} +- mount: string
get
- get
Service Documentation(mount): Promise<SwaggerJson> Retrieves an Open API compatible Swagger API description object for the +service installed at the given mount point.
+Parameters
- mount: string
The service's mount point, relative to the database.
+
Returns Promise<SwaggerJson>
Example
+const db = new Database();
const spec = await db.getServiceDocumentation("/my-service");
// spec is a Swagger API description of the service +- mount: string
get
- get
Service Readme(mount): Promise<undefined | string> Retrieves the text content of the service's
+READMEorREADME.mdfile.Returns
+undefinedif no such file could be found.Parameters
- mount: string
The service's mount point, relative to the database.
+
Returns Promise<undefined | string>
Example
+const db = new Database();
const readme = await db.getServiceReadme("/my-service");
if (readme !== undefined) console.log(readme);
else console.warn(`No README found.`) +- mount: string
get
- get
User(username): Promise<ArangoApiResponse<ArangoUser>> Fetches the user data of a single ArangoDB user.
+Parameters
- username: string
Name of the ArangoDB user to fetch.
+
Returns Promise<ArangoApiResponse<ArangoUser>>
Example
+const db = new Database();
const user = await db.getUser("steve");
// user is the user object for the user named "steve" +- username: string
get
- get
User Access Level(username, __namedParameters): Promise<AccessLevel> Fetches the given ArangoDB user's access level for the database, or the +given collection in the given database.
+Parameters
- username: string
Name of the ArangoDB user to fetch the access level for.
+ - __namedParameters: UserAccessLevelOptions
Returns Promise<AccessLevel>
Example
+const db = new Database();
const accessLevel = await db.getUserAccessLevel("steve");
// The access level of the user "steve" has been fetched for the current
// database. +Example
+const db = new Database();
const accessLevel = await db.getUserAccessLevel("steve", {
database: "staging"
});
// The access level of the user "steve" has been fetched for the "staging"
// database. +Example
+const db = new Database();
const accessLevel = await db.getUserAccessLevel("steve", {
collection: "pokemons"
});
// The access level of the user "steve" has been fetched for the
// "pokemons" collection in the current database. +Example
+const db = new Database();
const accessLevel = await db.getUserAccessLevel("steve", {
database: "staging",
collection: "pokemons"
});
// The access level of the user "steve" has been fetched for the
// "pokemons" collection in the "staging" database. +Example
+const db = new Database();
const staging = db.database("staging");
const accessLevel = await db.getUserAccessLevel("steve", {
database: staging
});
// The access level of the user "steve" has been fetched for the "staging"
// database. +Example
+const db = new Database();
const staging = db.database("staging");
const accessLevel = await db.getUserAccessLevel("steve", {
collection: staging.collection("pokemons")
});
// The access level of the user "steve" has been fetched for the
// "pokemons" collection in database "staging". +- username: string
get
- get
User Databases(username, full?): Promise<Record<string, AccessLevel>> Fetches an object mapping names of databases to the access level of the +given ArangoDB user for those databases.
+Parameters
- username: string
Name of the ArangoDB user to fetch the access levels for.
+ Optionalfull: falseWhether access levels for collections should be included.
+
Returns Promise<Record<string, AccessLevel>>
Example
+const db = new Database();
const accessLevels = await db.getUserDatabases("steve");
for (const [databaseName, accessLevel] of Object.entries(accessLevels)) {
console.log(`${databaseName}: ${accessLevel}`);
} +- username: string
- get
User Databases(username, full): Promise<Record<string, {
collections: Record<string, "undefined" | AccessLevel>;
permission: AccessLevel;
}>> Fetches an object mapping names of databases to the access level of the +given ArangoDB user for those databases and the collections within each +database.
+Parameters
- username: string
Name of the ArangoDB user to fetch the access levels for.
+ - full: true
Whether access levels for collections should be included.
+
Returns Promise<Record<string, {
collections: Record<string, "undefined" | AccessLevel>;
permission: AccessLevel;
}>>Example
+const db = new Database();
const accessLevels = await db.getUserDatabases("steve", true);
for (const [databaseName, obj] of Object.entries(accessLevels)) {
console.log(`${databaseName}: ${obj.permission}`);
for (const [collectionName, accessLevel] of Object.entries(obj.collections)) {
console.log(`${databaseName}/${collectionName}: ${accessLevel}`);
}
} +- username: string
graph
- graph(graphName): Graph
Returns a graph.Graph instance representing the graph with the given +
+graphName.Parameters
- graphName: string
Name of the graph.
+
Returns Graph
Example
+const db = new Database();
const graph = db.graph("some-graph"); +- graphName: string
graphs
- graphs(): Promise<Graph[]>
Fetches all graphs from the database and returns an array of graph.Graph +instances for those graphs.
+See also Database#listGraphs.
+Returns Promise<Graph[]>
Example
+const db = new Database();
const graphs = await db.graphs();
// graphs is an array of Graph instances +
install
- install
Service(mount, source, options?): Promise<ServiceInfo> Installs a new service.
+Parameters
- mount: string
The service's mount point, relative to the database.
+ - source: string | Blob | File
The service bundle to install.
+ - options: InstallServiceOptions = {}
Options for installing the service.
+
Returns Promise<ServiceInfo>
Example
+const db = new Database();
// Using a Buffer in Node.js as source
const source = new Blob([await fs.readFileSync("./my-foxx-service.zip")]);
const info = await db.installService("/hello", source); +Example
+const db = new Database();
// Using a Blob in Node.js as source
const source = await fs.openAsBlob("./my-foxx-service.zip");
const info = await db.installService("/hello", source); +Example
+const db = new Database();
// Using a File from a browser file input as source
const element = document.getElementById("my-file-input");
const source = element.files[0];
const info = await db.installService("/hello", source); +- mount: string
job
kill
- kill
Query(queryId): Promise<void> Kills a running query with the given
+queryId.See also Database#listRunningQueries.
+Parameters
- queryId: string
The ID of a currently running query.
+
Returns Promise<void>
Example
+const db = new Database();
const queries = await db.listRunningQueries();
await Promise.all(queries.map(
async (query) => {
if (query.state === "executing") {
await db.killQuery(query.id);
}
}
)); +- queryId: string
list
- list
Analyzers(): Promise<AnalyzerDescription[]> Fetches all Analyzers visible in the database and returns an array of +Analyzer descriptions.
+See also Database#analyzers.
+Returns Promise<AnalyzerDescription[]>
Example
+const db = new Database();
const analyzers = await db.listAnalyzers();
// analyzers is an array of Analyzer descriptions +
list
- list
Collections(excludeSystem?): Promise<CollectionMetadata[]> Fetches all collections from the database and returns an array of +collection descriptions.
+See also Database#collections.
+Parameters
- excludeSystem: boolean = true
Whether system collections should be excluded.
+
Returns Promise<CollectionMetadata[]>
Example
+const db = new Database();
const collections = await db.listCollections();
// collections is an array of collection descriptions
// not including system collections +Example
+const db = new Database();
const collections = await db.listCollections(false);
// collections is an array of collection descriptions
// including system collections +- excludeSystem: boolean = true
list
list
- list
Databases(): Promise<string[]> Fetches all databases from the server and returns an array of their names.
+See also Database#databases and +Database#listUserDatabases.
+Returns Promise<string[]>
Example
+const db = new Database();
const names = await db.listDatabases();
// databases is an array of database names +
list
- list
Functions(): Promise<AqlUserFunction[]> Fetches a list of all AQL user functions registered with the database.
+Returns Promise<AqlUserFunction[]>
Example
+const db = new Database();
const functions = await db.listFunctions();
const names = functions.map(fn => fn.name); +
list
- list
Graphs(): Promise<GraphInfo[]> Fetches all graphs from the database and returns an array of graph +descriptions.
+See also Database#graphs.
+Returns Promise<GraphInfo[]>
Example
+const db = new Database();
const graphs = await db.listGraphs();
// graphs is an array of graph descriptions +
list
- list
Hot Backups(id?): Promise<HotBackupList> (Enterprise Edition only.) Retrieves a list of all locally found hot +backups.
+Parameters
Optionalid: string | string[]If specified, only the backup with the given ID will be +returned.
+
Returns Promise<HotBackupList>
Example
+const backups = await db.listHotBackups();
for (const backup of backups) {
console.log(backup.id);
} +
list
list
- list
Running Queries(): Promise<QueryInfo[]> Fetches a list of information for all currently running queries.
+See also Database#listSlowQueries and Database#killQuery.
+Returns Promise<QueryInfo[]>
Example
+const db = new Database();
const queries = await db.listRunningQueries(); +
list
- list
Service Scripts(mount): Promise<Record<string, string>> Retrieves a list of scripts defined in the service manifest's "scripts" +section mapped to their human readable representations.
+Parameters
- mount: string
The service's mount point, relative to the database.
+
Returns Promise<Record<string, string>>
Example
+const db = new Database();
const scripts = await db.listServiceScripts("/my-service");
for (const [name, title] of Object.entries(scripts)) {
console.log(`${name}: ${title}`);
} +- mount: string
list
- list
Services(excludeSystem?): Promise<ServiceSummary[]> Fetches a list of all installed service.
+Parameters
- excludeSystem: boolean = true
Whether system services should be excluded.
+
Returns Promise<ServiceSummary[]>
Example
+const db = new Database();
const services = await db.listServices(); +Example
+const db = new Database();
const services = await db.listServices(false); // all services +- excludeSystem: boolean = true
list
- list
Slow Queries(): Promise<QueryInfo[]> Fetches a list of information for all recent slow queries.
+See also Database#listRunningQueries and +Database#clearSlowQueries.
+Returns Promise<QueryInfo[]>
Example
+const db = new Database();
const queries = await db.listSlowQueries();
// Only works if slow query tracking is enabled +
list
- list
Transactions(): Promise<TransactionDetails[]> Fetches all active transactions from the database and returns an array of +transaction descriptions.
+See also Database#transactions.
+Returns Promise<TransactionDetails[]>
Example
+const db = new Database();
const transactions = await db.listTransactions();
// transactions is an array of transaction descriptions +
list
- list
User Databases(): Promise<string[]> Fetches all databases accessible to the active user from the server and +returns an array of their names.
+See also Database#userDatabases and +Database#listDatabases.
+Returns Promise<string[]>
Example
+const db = new Database();
const names = await db.listUserDatabases();
// databases is an array of database names +
list
- list
Users(): Promise<ArangoUser[]> Fetches all ArangoDB users visible to the authenticated user and returns +an array of user objects.
+Returns Promise<ArangoUser[]>
Example
+const db = new Database();
const users = await db.listUsers();
// users is an array of user objects +
list
- list
Views(): Promise<ViewDescription[]> Fetches all Views from the database and returns an array of View +descriptions.
+See also Database#views.
+Returns Promise<ViewDescription[]>
Example
+const db = new Database();
const views = await db.listViews();
// views is an array of View descriptions +
login
- login(username?, password?): Promise<string>
Validates the given database credentials and exchanges them for an +authentication token, then uses the authentication token for future +requests and returns it.
+Parameters
- username: string = "root"
The username to authenticate with.
+ - password: string = ""
The password to authenticate with.
+
Returns Promise<string>
Example
+const db = new Database();
await db.login("admin", "hunter2");
// with an authentication token for the "admin" user. +- username: string = "root"
parse
- parse(query): Promise<ParseResult>
Parses the given query and returns the result.
+See the aql!aql template string handler for information about how +to create a query string without manually defining bind parameters nor +having to worry about escaping variables.
+Parameters
- query: string | AqlLiteral | AqlQuery<any>
An AQL query string or an object containing an AQL query +string and bind parameters, e.g. the object returned from an aql!aql +template string.
+
Returns Promise<ParseResult>
Example
+const db = new Database();
const collection = db.collection("some-collection");
const ast = await db.parse(aql`
FOR doc IN ${collection}
FILTER doc.flavor == "strawberry"
RETURN doc._key
`); +- query: string | AqlLiteral | AqlQuery<any>
query
- query<T>(query, options?): Promise<ArrayCursor<T>>
Performs a database query using the given
+query, then returns a new +cursor.ArrayCursor instance for the result set.See the aql!aql template string handler for information about how +to create a query string without manually defining bind parameters nor +having to worry about escaping variables.
+Note: When executing a query in a streaming transaction using the +
+stepmethod, the resulting cursor will be bound to that transaction and +you do not need to use thestepmethod to consume it.Type Parameters
Parameters
- query: AqlQuery<T>
An object containing an AQL query string and bind +parameters, e.g. the object returned from an aql!aql template string.
+ Optionaloptions: QueryOptionsOptions for the query execution.
+
Returns Promise<ArrayCursor<T>>
Example
+const db = new Database();
const active = true;
const Users = db.collection("_users");
// Using an aql template string:
// Bind parameters are automatically extracted and arangojs collections
// are automatically passed as collection bind parameters.
const cursor = await db.query(aql`
FOR u IN ${Users}
FILTER u.authData.active == ${active}
RETURN u.user
`);
// cursor is a cursor for the query result +Example
+const db = new Database();
const active = true;
const Users = db.collection("_users");
// Using an object with a regular multi-line string
const cursor = await db.query({
query: `
FOR u IN @@users
FILTER u.authData.active == @active
RETURN u.user
`,
bindVars: { active: active, "@users": Users.name }
}); +- query: AqlQuery<T>
- query<T>(query, bindVars?, options?): Promise<ArrayCursor<T>>
Performs a database query using the given
+queryandbindVars, then +returns a new cursor.ArrayCursor instance for the result set.See the aql!aql template string handler for a safer and easier +alternative to passing strings directly.
+Note: When executing a query in a streaming transaction using the +
+stepmethod, the resulting cursor will be bound to that transaction and +you do not need to use thestepmethod to consume it.Type Parameters
Parameters
- query: string | AqlLiteral
An AQL query string.
+ OptionalbindVars: Record<string, any>An object defining bind parameters for the query.
+Optionaloptions: QueryOptionsOptions for the query execution.
+
Returns Promise<ArrayCursor<T>>
Example
+const db = new Database();
const active = true;
const Users = db.collection("_users");
const cursor = await db.query(
// A normal multi-line string
`
FOR u IN @@users
FILTER u.authData.active == @active
RETURN u.user
`,
{ active: active, "@users": Users.name }
); +Example
+const db = new Database();
const active = true;
const Users = db.collection("_users");
const cursor = await db.query(
// An AQL literal created from a normal multi-line string
aql.literal(`
FOR u IN @@users
FILTER u.authData.active == @active
RETURN u.user
`),
{ active: active, "@users": Users.name }
); +- query: string | AqlLiteral
query
- query
Rules(): Promise<QueryOptimizerRule[]> Fetches the available optimizer rules.
+Returns Promise<QueryOptimizerRule[]>
Example
+const db = new Database();
const rules = await db.queryRules();
for (const rule of rules) {
console.log(rule.name);
} +
query
- query
Tracking(): Promise<QueryTracking> Fetches the query tracking properties.
+Returns Promise<QueryTracking>
Example
+const db = new Database();
const tracking = await db.queryTracking();
console.log(tracking.enabled); +- query
Tracking(options): Promise<QueryTracking> Modifies the query tracking properties.
+Parameters
- options: QueryTrackingOptions
Options for query tracking.
+
Returns Promise<QueryTracking>
Example
+const db = new Database();
// track up to 5 slow queries exceeding 5 seconds execution time
await db.setQueryTracking({
enabled: true,
trackSlowQueries: true,
maxSlowQueries: 5,
slowQueryThreshold: 5
}); +- options: QueryTrackingOptions
rebalance
- rebalance
Cluster(opts): Promise<ClusterRebalanceResult> Computes a set of move shard operations to rebalance the cluster and +executes them.
+Parameters
- opts: ClusterRebalanceOptions
Returns Promise<ClusterRebalanceResult>
Example
+const db = new Database();
const result = await db.rebalanceCluster({
moveLeaders: true,
moveFollowers: true
});
// The cluster is now rebalanced. +
remove
- remove
User(username): Promise<ArangoApiResponse<Record<string, never>>> Removes the ArangoDB user with the given username from the server.
+Parameters
- username: string
Name of the ArangoDB user to remove.
+
Returns Promise<ArangoApiResponse<Record<string, never>>>
Example
+const db = new Database();
await db.removeUser("steve");
// The user "steve" has been removed +- username: string
rename
- rename
Collection(collectionName, newName): Promise<ArangoApiResponse<CollectionMetadata>> Renames the collection
+collectionNametonewName.Additionally removes any stored
+Collectioninstance for +collectionNamefrom theDatabaseinstance's internal cache.Note: Renaming collections may not be supported when ArangoDB is +running in a cluster configuration.
+Parameters
- collectionName: string
Current name of the collection.
+ - newName: string
The new name of the collection.
+
Returns Promise<ArangoApiResponse<CollectionMetadata>>
- collectionName: string
rename
- rename
View(viewName, newName): Promise<ArangoApiResponse<ViewDescription>> Renames the view
+viewNametonewName.Additionally removes any stored view.View instance for
+viewNamefrom +theDatabaseinstance's internal cache.Note: Renaming views may not be supported when ArangoDB is running in +a cluster configuration.
+Parameters
- viewName: string
Current name of the view.
+ - newName: string
The new name of the view.
+
Returns Promise<ArangoApiResponse<ViewDescription>>
- viewName: string
renew
- renew
Auth Token(): Promise<null | string> Attempts to renew the authentication token passed to Database#useBearerAuth +or returned and used by Database#login. If a new authentication +token is issued, it will be used for future requests and returned.
+Returns Promise<null | string>
Example
+const db = new Database();
await db.login("admin", "hunter2");
// ... later ...
const newToken = await db.renewAuthToken();
if (!newToken) // no new token issued +
replace
- replace
Service(mount, source, options?): Promise<ServiceInfo> Replaces an existing service with a new service by completely removing the +old service and installing a new service at the same mount point.
+Parameters
- mount: string
The service's mount point, relative to the database.
+ - source: string | Blob | File
The service bundle to install.
+ - options: ReplaceServiceOptions = {}
Options for replacing the service.
+
Returns Promise<ServiceInfo>
Example
+const db = new Database();
// Using a Buffer in Node.js as source
const source = new Blob([await fs.readFileSync("./my-foxx-service.zip")]);
const info = await db.replaceService("/hello", source); +Example
+const db = new Database();
// Using a Blob in Node.js as source
const source = await fs.openAsBlob("./my-foxx-service.zip");
const info = await db.replaceService("/hello", source); +Example
+const db = new Database();
// Using a File from a browser file input as source
const element = document.getElementById("my-file-input");
const source = element.files[0];
const info = await db.replaceService("/hello", source); +- mount: string
replace
- replace
Service Configuration(mount, cfg, minimal?): Promise<Record<string, ServiceConfiguration & {
warning?: string;
}>> Replaces the configuration of the given service, discarding any existing +values for options not specified.
+See also Database#updateServiceConfiguration and +Database#getServiceConfiguration.
+Parameters
- mount: string
The service's mount point, relative to the database.
+ - cfg: Record<string, any>
An object mapping configuration option names to values.
+ Optionalminimal: falseIf set to
+true, the result will only include each +configuration option's current value and warning (if any). +Otherwise it will include the full definition for each option.
Returns Promise<Record<string, ServiceConfiguration & {
warning?: string;
}>>Example
+const db = new Database();
const config = { currency: "USD", locale: "en-US" };
const info = await db.replaceServiceConfiguration("/my-service", config);
for (const [key, option] of Object.entries(info)) {
console.log(`${option.title} (${key}): ${option.value}`);
if (option.warning) console.warn(`Warning: ${option.warning}`);
} +- mount: string
- replace
Service Configuration(mount, cfg, minimal): Promise<{
values: Record<string, any>;
warnings: Record<string, string>;
}> Replaces the configuration of the given service, discarding any existing +values for options not specified.
+See also Database#updateServiceConfiguration and +Database#getServiceConfiguration.
+Parameters
- mount: string
The service's mount point, relative to the database.
+ - cfg: Record<string, any>
An object mapping configuration option names to values.
+ - minimal: true
If set to
+true, the result will only include each +configuration option's current value and warning (if any). +Otherwise it will include the full definition for each option.
Returns Promise<{
values: Record<string, any>;
warnings: Record<string, string>;
}>Example
+const db = new Database();
const config = { currency: "USD", locale: "en-US" };
const info = await db.replaceServiceConfiguration("/my-service", config);
for (const [key, value] of Object.entries(info.values)) {
console.log(`${key}: ${value}`);
if (info.warnings[key]) console.warn(`Warning: ${info.warnings[key]}`);
} +- mount: string
replace
- replace
Service Dependencies(mount, deps, minimal?): Promise<Record<string, (SingleServiceDependency | MultiServiceDependency) & {
warning?: string;
}>> Replaces the dependencies of the given service, discarding any existing +mount points for dependencies not specified.
+See also Database#updateServiceDependencies and +Database#getServiceDependencies.
+Parameters
- mount: string
The service's mount point, relative to the database.
+ - deps: Record<string, string>
Optionalminimal: falseIf set to
+true, the result will only include each +dependency's current mount point. Otherwise it will include the full +definition for each dependency.
Returns Promise<Record<string, (SingleServiceDependency | MultiServiceDependency) & {
warning?: string;
}>>Example
+const db = new Database();
const deps = { mailer: "/mailer-api", auth: "/remote-auth" };
const info = await db.replaceServiceDependencies("/my-service", deps);
for (const [key, dep] of Object.entries(info)) {
console.log(`${dep.title} (${key}): ${dep.current}`);
if (dep.warning) console.warn(`Warning: ${dep.warning}`);
} +- mount: string
- replace
Service Dependencies(mount, deps, minimal): Promise<{
values: Record<string, string>;
warnings: Record<string, string>;
}> Replaces the dependencies of the given service, discarding any existing +mount points for dependencies not specified.
+See also Database#updateServiceDependencies and +Database#getServiceDependencies.
+Parameters
- mount: string
The service's mount point, relative to the database.
+ - deps: Record<string, string>
- minimal: true
If set to
+true, the result will only include each +dependency's current mount point. Otherwise it will include the full +definition for each dependency.
Returns Promise<{
values: Record<string, string>;
warnings: Record<string, string>;
}>Example
+const db = new Database();
const deps = { mailer: "/mailer-api", auth: "/remote-auth" };
const info = await db.replaceServiceDependencies(
"/my-service",
deps,
true
);
for (const [key, value] of Object.entries(info)) {
console.log(`${key}: ${value}`);
if (info.warnings[key]) console.warn(`Warning: ${info.warnings[key]}`);
} +- mount: string
replace
- replace
User(username, options): Promise<ArangoApiResponse<ArangoUser>> Replaces the ArangoDB user's option with the new options.
+Parameters
- username: string
Name of the ArangoDB user to modify.
+ - options: UserOptions
New options to replace the user's existing options.
+
Returns Promise<ArangoApiResponse<ArangoUser>>
Example
+const db = new Database();
const user = await db.replaceUser("steve", { passwd: "", active: false });
// The user "steve" has been set to inactive with an empty password +- username: string
restore
- restore
Hot Backup(id): Promise<string> (Enteprise Edition only.) Restores a consistent local hot backup.
+Returns the directory path of the restored backup.
+Parameters
- id: string
The ID of the backup to restore.
+
Returns Promise<string>
Example
+await db.restoreHotBackup("2023-09-19T15.38.21Z_example");
// the backup has been restored +- id: string
route
- route(path?, headers?): Route
Returns a new route.Route instance for the given path (relative to the +database) that can be used to perform arbitrary HTTP requests.
+Parameters
Optionalpath: stringThe database-relative URL of the route. Defaults to the +database API root.
+Optionalheaders: Headers | Record<string, string>Default headers that should be sent with each request to +the route.
+
Returns Route
Example
+const db = new Database();
const myFoxxService = db.route("my-foxx-service");
const response = await myFoxxService.post("users", {
username: "admin",
password: "hunter2"
});
// response.body is the result of
// POST /_db/_system/my-foxx-service/users
// with JSON request body '{"username": "admin", "password": "hunter2"}' +
run
- run
Service Script(mount, name, params?): Promise<any> Executes a service script and retrieves its result exposed as +
+module.exports(if any).Parameters
- mount: string
The service's mount point, relative to the database.
+ - name: string
Name of the service script to execute as defined in the +service manifest.
+ Optionalparams: anyArbitrary value that will be exposed to the script as +
+argv[0]in the service context (e.g.module.context.argv[0]). +Must be serializable to JSON.
Returns Promise<any>
Example
+const db = new Database();
const result = await db.runServiceScript(
"/my-service",
"create-user",
{
username: "service_admin",
password: "hunter2"
}
); +- mount: string
run
- run
Service Tests(mount, options?): Promise<ServiceTestDefaultReport> Runs the tests of a given service and returns the results using the +"default" reporter.
+Parameters
- mount: string
The service's mount point, relative to the database.
+ Optionaloptions: {
filter?: string;
idiomatic?: false;
reporter?: "default";
}Options for running the tests.
+Optionalfilter?: stringIf set, only tests with full names including this exact string will be +executed.
+Optionalidiomatic?: falseWhether the reporter should use "idiomatic" mode. Has no effect when +using the "default" or "suite" reporters.
+Optionalreporter?: "default"
Returns Promise<ServiceTestDefaultReport>
Example
+const db = new Database();
const testReport = await db.runServiceTests("/my-foxx"); +- mount: string
- run
Service Tests(mount, options): Promise<ServiceTestSuiteReport> Runs the tests of a given service and returns the results using the +"suite" reporter, which groups the test result by test suite.
+Parameters
- mount: string
The service's mount point, relative to the database.
+ - options: {
filter?: string;
idiomatic?: false;
reporter: "suite";
}Options for running the tests.
+Optionalfilter?: stringIf set, only tests with full names including this exact string will be +executed.
+Optionalidiomatic?: falseWhether the reporter should use "idiomatic" mode. Has no effect when +using the "default" or "suite" reporters.
+reporter: "suite"
Returns Promise<ServiceTestSuiteReport>
Example
+const db = new Database();
const suiteReport = await db.runServiceTests(
"/my-foxx",
{ reporter: "suite" }
); +- mount: string
- run
Service Tests(mount, options): Promise<ServiceTestStreamReport> Runs the tests of a given service and returns the results using the +"stream" reporter, which represents the results as a sequence of tuples +representing events.
+Parameters
- mount: string
The service's mount point, relative to the database.
+ - options: {
filter?: string;
idiomatic?: false;
reporter: "stream";
}Options for running the tests.
+Optionalfilter?: stringIf set, only tests with full names including this exact string will be +executed.
+Optionalidiomatic?: falseWhether the reporter should use "idiomatic" mode. If set to
+true, +the results will be returned as a formatted string.reporter: "stream"
Returns Promise<ServiceTestStreamReport>
Example
+const db = new Database();
const streamEvents = await db.runServiceTests(
"/my-foxx",
{ reporter: "stream" }
); +- mount: string
- run
Service Tests(mount, options): Promise<ServiceTestTapReport> Runs the tests of a given service and returns the results using the +"tap" reporter, which represents the results as an array of strings using +the "tap" format.
+Parameters
- mount: string
The service's mount point, relative to the database.
+ - options: {
filter?: string;
idiomatic?: false;
reporter: "tap";
}Options for running the tests.
+Optionalfilter?: stringIf set, only tests with full names including this exact string will be +executed.
+Optionalidiomatic?: falseWhether the reporter should use "idiomatic" mode. If set to
+true, +the results will be returned as a formatted string.reporter: "tap"
Returns Promise<ServiceTestTapReport>
Example
+const db = new Database();
const tapLines = await db.runServiceTests(
"/my-foxx",
{ reporter: "tap" }
); +- mount: string
- run
Service Tests(mount, options): Promise<ServiceTestXunitReport> Runs the tests of a given service and returns the results using the +"xunit" reporter, which represents the results as an XML document using +the JSONML exchange format.
+Parameters
- mount: string
The service's mount point, relative to the database.
+ - options: {
filter?: string;
idiomatic?: false;
reporter: "xunit";
}Options for running the tests.
+Optionalfilter?: stringIf set, only tests with full names including this exact string will be +executed.
+Optionalidiomatic?: falseWhether the reporter should use "idiomatic" mode. If set to
+true, +the results will be returned as a formatted string.reporter: "xunit"
Returns Promise<ServiceTestXunitReport>
Example
+const db = new Database();
const jsonML = await db.runServiceTests(
"/my-foxx",
{ reporter: "xunit" }
); +- mount: string
- run
Service Tests(mount, options): Promise<string> Runs the tests of a given service and returns the results as a string +using the "stream" reporter in "idiomatic" mode, which represents the +results as a line-delimited JSON stream of tuples representing events.
+Parameters
- mount: string
The service's mount point, relative to the database.
+ - options: {
filter?: string;
idiomatic: true;
reporter: "stream";
}Options for running the tests.
+Optionalfilter?: stringIf set, only tests with full names including this exact string will be +executed.
+idiomatic: true
Whether the reporter should use "idiomatic" mode. If set to
+false, +the results will be returned as an array of tuples instead of a +string.reporter: "stream"
Returns Promise<string>
Example
+const db = new Database();
const streamReport = await db.runServiceTests(
"/my-foxx",
{ reporter: "stream", idiomatic: true }
); +- mount: string
- run
Service Tests(mount, options): Promise<string> Runs the tests of a given service and returns the results as a string +using the "tap" reporter in "idiomatic" mode, which represents the +results using the "tap" format.
+Parameters
- mount: string
The service's mount point, relative to the database.
+ - options: {
filter?: string;
idiomatic: true;
reporter: "tap";
}Options for running the tests.
+Optionalfilter?: stringIf set, only tests with full names including this exact string will be +executed.
+idiomatic: true
Whether the reporter should use "idiomatic" mode. If set to
+false, +the results will be returned as an array of strings instead of a +single string.reporter: "tap"
Returns Promise<string>
Example
+const db = new Database();
const tapReport = await db.runServiceTests(
"/my-foxx",
{ reporter: "tap", idiomatic: true }
); +- mount: string
- run
Service Tests(mount, options): Promise<string> Runs the tests of a given service and returns the results as a string +using the "xunit" reporter in "idiomatic" mode, which represents the +results as an XML document.
+Parameters
- mount: string
The service's mount point, relative to the database.
+ - options: {
filter?: string;
idiomatic: true;
reporter: "xunit";
}Options for running the tests.
+Optionalfilter?: stringIf set, only tests with full names including this exact string will be +executed.
+idiomatic: true
Whether the reporter should use "idiomatic" mode. If set to
+false, +the results will be returned using the JSONML exchange format +instead of a string.reporter: "xunit"
Returns Promise<string>
Example
+const db = new Database();
const xml = await db.runServiceTests(
"/my-foxx",
{ reporter: "xunit", idiomatic: true }
); +- mount: string
set
- set
Log Level(levels): Promise<Record<string, LogLevelSetting>> Sets the server's log level for each of the given topics to the given level.
+Any omitted topics will be left unchanged.
+Parameters
- levels: Record<string, LogLevelSetting>
An object mapping topic names to log levels.
+
Returns Promise<Record<string, LogLevelSetting>>
Example
+await db.setLogLevel({ request: "debug" });
// Debug information will now be logged for each request +- levels: Record<string, LogLevelSetting>
set
- set
Response Queue Time Samples(responseQueueTimeSamples): void Sets the limit for the number of values of the most recently received +server-reported queue times that can be accessed using +Database#queueTime.
+Parameters
- responseQueueTimeSamples: number
Number of values to maintain.
+
Returns void
- responseQueueTimeSamples: number
set
- set
Service Development Mode(mount, enabled?): Promise<ServiceInfo> Enables or disables development mode for the given service.
+Parameters
- mount: string
The service's mount point, relative to the database.
+ - enabled: boolean = true
Whether development mode should be enabled or disabled.
+
Returns Promise<ServiceInfo>
Example
+const db = new Database();
await db.setServiceDevelopmentMode("/my-service", true);
// the service is now in development mode
await db.setServiceDevelopmentMode("/my-service", false);
// the service is now in production mode +- mount: string
set
- set
User Access Level(username, __namedParameters): Promise<ArangoApiResponse<Record<string, AccessLevel>>> Sets the given ArangoDB user's access level for the database, or the +given collection in the given database.
+Parameters
- username: string
Name of the ArangoDB user to set the access level for.
+ - __namedParameters: UserAccessLevelOptions & {
grant: AccessLevel;
}
Returns Promise<ArangoApiResponse<Record<string, AccessLevel>>>
Example
+const db = new Database();
await db.setUserAccessLevel("steve", { grant: "rw" });
// The user "steve" now has read-write access to the current database. +Example
+const db = new Database();
await db.setUserAccessLevel("steve", {
database: "staging",
grant: "rw"
});
// The user "steve" now has read-write access to the "staging" database. +Example
+const db = new Database();
await db.setUserAccessLevel("steve", {
collection: "pokemons",
grant: "rw"
});
// The user "steve" now has read-write access to the "pokemons" collection
// in the current database. +Example
+const db = new Database();
await db.setUserAccessLevel("steve", {
database: "staging",
collection: "pokemons",
grant: "rw"
});
// The user "steve" now has read-write access to the "pokemons" collection
// in the "staging" database. +Example
+const db = new Database();
const staging = db.database("staging");
await db.setUserAccessLevel("steve", {
database: staging,
grant: "rw"
});
// The user "steve" now has read-write access to the "staging" database. +Example
+const db = new Database();
const staging = db.database("staging");
await db.setUserAccessLevel("steve", {
collection: staging.collection("pokemons"),
grant: "rw"
});
// The user "steve" now has read-write access to the "pokemons" collection
// in database "staging". +- username: string
shutdown
time
transaction
- transaction(transactionId): Transaction
Returns a transaction.Transaction instance for an existing streaming +transaction with the given
+id.See also Database#beginTransaction.
+Parameters
- transactionId: string
Returns Transaction
Example
+const trx1 = await db.beginTransaction(collections);
const id = trx1.id;
// later
const trx2 = db.transaction(id);
await trx2.commit(); +
transactions
- transactions(): Promise<Transaction[]>
Fetches all active transactions from the database and returns an array of +transaction.Transaction instances for those transactions.
+See also Database#listTransactions.
+Returns Promise<Transaction[]>
Example
+const db = new Database();
const transactions = await db.transactions();
// transactions is an array of transactions +
uninstall
- uninstall
Service(mount, options?): Promise<void> Completely removes a service from the database.
+Parameters
- mount: string
The service's mount point, relative to the database.
+ Optionaloptions: UninstallServiceOptionsOptions for uninstalling the service.
+
Returns Promise<void>
Example
+const db = new Database();
await db.uninstallService("/my-foxx"); +- mount: string
update
- update
Service Configuration(mount, cfg, minimal?): Promise<Record<string, ServiceConfiguration & {
warning?: string;
}>> Updates the configuration of the given service while maintaining any +existing values for options not specified.
+See also Database#replaceServiceConfiguration and +Database#getServiceConfiguration.
+Parameters
- mount: string
The service's mount point, relative to the database.
+ - cfg: Record<string, any>
An object mapping configuration option names to values.
+ Optionalminimal: falseIf set to
+true, the result will only include each +configuration option's current value and warning (if any). +Otherwise it will include the full definition for each option.
Returns Promise<Record<string, ServiceConfiguration & {
warning?: string;
}>>Example
+const db = new Database();
const config = { currency: "USD", locale: "en-US" };
const info = await db.updateServiceConfiguration("/my-service", config);
for (const [key, option] of Object.entries(info)) {
console.log(`${option.title} (${key}): ${option.value}`);
if (option.warning) console.warn(`Warning: ${option.warning}`);
} +- mount: string
- update
Service Configuration(mount, cfg, minimal): Promise<{
values: Record<string, any>;
warnings: Record<string, string>;
}> Updates the configuration of the given service while maintaining any +existing values for options not specified.
+See also Database#replaceServiceConfiguration and +Database#getServiceConfiguration.
+Parameters
- mount: string
The service's mount point, relative to the database.
+ - cfg: Record<string, any>
An object mapping configuration option names to values.
+ - minimal: true
If set to
+true, the result will only include each +configuration option's current value and warning (if any). +Otherwise it will include the full definition for each option.
Returns Promise<{
values: Record<string, any>;
warnings: Record<string, string>;
}>Example
+const db = new Database();
const config = { currency: "USD", locale: "en-US" };
const info = await db.updateServiceConfiguration("/my-service", config);
for (const [key, value] of Object.entries(info.values)) {
console.log(`${key}: ${value}`);
if (info.warnings[key]) console.warn(`Warning: ${info.warnings[key]}`);
} +- mount: string
update
- update
Service Dependencies(mount, deps, minimal?): Promise<Record<string, (SingleServiceDependency | MultiServiceDependency) & {
warning?: string;
}>> Updates the dependencies of the given service while maintaining any +existing mount points for dependencies not specified.
+See also Database#replaceServiceDependencies and +Database#getServiceDependencies.
+Parameters
- mount: string
The service's mount point, relative to the database.
+ - deps: Record<string, string>
Optionalminimal: falseIf set to
+true, the result will only include each +dependency's current mount point. Otherwise it will include the full +definition for each dependency.
Returns Promise<Record<string, (SingleServiceDependency | MultiServiceDependency) & {
warning?: string;
}>>Example
+const db = new Database();
const deps = { mailer: "/mailer-api", auth: "/remote-auth" };
const info = await db.updateServiceDependencies("/my-service", deps);
for (const [key, dep] of Object.entries(info)) {
console.log(`${dep.title} (${key}): ${dep.current}`);
if (dep.warning) console.warn(`Warning: ${dep.warning}`);
} +- mount: string
- update
Service Dependencies(mount, deps, minimal): Promise<{
values: Record<string, string>;
warnings: Record<string, string>;
}> Updates the dependencies of the given service while maintaining any +existing mount points for dependencies not specified.
+See also Database#replaceServiceDependencies and +Database#getServiceDependencies.
+Parameters
- mount: string
The service's mount point, relative to the database.
+ - deps: Record<string, string>
- minimal: true
If set to
+true, the result will only include each +dependency's current mount point. Otherwise it will include the full +definition for each dependency.
Returns Promise<{
values: Record<string, string>;
warnings: Record<string, string>;
}>Example
+const db = new Database();
const deps = { mailer: "/mailer-api", auth: "/remote-auth" };
const info = await db.updateServiceDependencies(
"/my-service",
deps,
true
);
for (const [key, value] of Object.entries(info)) {
console.log(`${key}: ${value}`);
if (info.warnings[key]) console.warn(`Warning: ${info.warnings[key]}`);
} +- mount: string
update
- update
User(username, passwd): Promise<ArangoApiResponse<ArangoUser>> Sets the password of a given ArangoDB user to the new value.
+Parameters
- username: string
Name of the ArangoDB user to change the password for.
+ - passwd: string
New password for the ArangoDB user.
+
Returns Promise<ArangoApiResponse<ArangoUser>>
Example
+const db = new Database();
const user = await db.updateUser("steve", "hunter2");
// The user "steve" has received a new password +- username: string
- update
User(username, options): Promise<ArangoApiResponse<ArangoUser>> Updates the ArangoDB user with the new options.
+Parameters
- username: string
Name of the ArangoDB user to modify.
+ - options: Partial<UserOptions>
Options of the ArangoDB user to modify.
+
Returns Promise<ArangoApiResponse<ArangoUser>>
Example
+const db = new Database();
const user = await db.updateUser("steve", { active: false });
// The user "steve" has been set to inactive +- username: string
upgrade
- upgrade
Service(mount, source, options?): Promise<ServiceInfo> Replaces an existing service with a new service while retaining the old +service's configuration and dependencies.
+Parameters
- mount: string
The service's mount point, relative to the database.
+ - source: string | Blob | File
The service bundle to install.
+ - options: UpgradeServiceOptions = {}
Options for upgrading the service.
+
Returns Promise<ServiceInfo>
Example
+const db = new Database();
// Using a Buffer in Node.js as source
const source = new Blob([await fs.readFileSync("./my-foxx-service.zip")]);
const info = await db.upgradeService("/hello", source); +Example
+const db = new Database();
// Using a Blob in Node.js as source
const source = await fs.openAsBlob("./my-foxx-service.zip");
const info = await db.upgradeService("/hello", source); +Example
+const db = new Database();
// Using a File from a browser file input as source
const element = document.getElementById("my-file-input");
const source = element.files[0];
const info = await db.upgradeService("/hello", source); +- mount: string
use
- use
Basic Auth(username?, password?): this Updates the underlying connection's
+authorizationheader to use Basic +authentication with the givenusernameandpassword, then returns +itself.Parameters
- username: string = "root"
The username to authenticate with.
+ - password: string = ""
The password to authenticate with.
+
Returns this
Example
+const db = new Database();
db.useBasicAuth("admin", "hunter2");
// with the username "admin" and password "hunter2". +- username: string = "root"
use
- use
Bearer Auth(token): this Updates the underlying connection's
+authorizationheader to use Bearer +authentication with the given authenticationtoken, then returns itself.Parameters
- token: string
The token to authenticate with.
+
Returns this
Example
+const db = new Database();
db.useBearerAuth("keyboardcat");
// The database instance now uses Bearer authentication. +- token: string
user
- user
Databases(): Promise<Database[]> Fetches all databases accessible to the active user from the server and +returns an array of
+Databaseinstances for those databases.See also Database#listUserDatabases and +Database#databases.
+Returns Promise<Database[]>
Example
+const db = new Database();
const names = await db.userDatabases();
// databases is an array of databases +
version
- version(details?): Promise<VersionInfo>
Fetches version information from the ArangoDB server.
+Parameters
Optionaldetails: booleanIf set to
+true, additional information about the +ArangoDB server will be available as thedetailsproperty.
Returns Promise<VersionInfo>
Example
+const db = new Database();
const version = await db.version();
// the version object contains the ArangoDB version information.
// license: "community" or "enterprise"
// version: ArangoDB version number
// server: description of the server +
view
views
- views(): Promise<View[]>
Fetches all Views from the database and returns an array of +view.View instances +for the Views.
+See also Database#listViews.
+Returns Promise<View[]>
Example
+const db = new Database();
const views = await db.views();
// views is an array of ArangoSearch View instances +
wait
- wait
For Propagation(request, timeout?): Promise<void> Performs a request against every known coordinator and returns when the +request has succeeded against every coordinator or the timeout is reached.
+Note: This method is primarily intended to make database setup easier +in cluster scenarios and requires all coordinators to be known to arangojs +before the method is invoked. The method is not useful in single-server or +leader-follower replication scenarios.
+Parameters
- request: RequestOptions
Request to perform against each known coordinator.
+ Optionaltimeout: numberMaximum number of milliseconds to wait for propagation.
+
Returns Promise<void>
Example
+const db = new Database({ loadBalancingStrategy: "ROUND_ROBIN" });
await system.acquireHostList();
const analyzer = db.analyzer("my-analyzer");
await analyzer.create();
await db.waitForPropagation(
{ path: `/_api/analyzer/${encodeURIComponent(analyzer.name)}` },
30000
);
// Analyzer has been propagated to all coordinators and can safely be used +- request: RequestOptions
with
- with
Transaction<T>(collections, callback, options?): Promise<T> Begins and commits a transaction using the given callback. Individual +requests that are part of the transaction need to be wrapped in the step +function passed into the callback. If the promise returned by the callback +is rejected, the transaction will be aborted.
+Collections can be specified as collection names (strings) or objects +implementing the collection.ArangoCollection interface:
+Collection, +graph.GraphVertexCollection, graph.GraphEdgeCollection as +well as (in TypeScript) collection.DocumentCollection and +collection.EdgeCollection.Type Parameters
Parameters
- collections: TransactionCollections
Collections involved in the transaction.
+ - callback: ((step) => Promise<T>)
Callback function executing the transaction steps.
+- (step): Promise<T>
Parameters
- step: (<T>(callback) => Promise<T>)
- <T>(callback): Promise<T>
Executes the given function locally as a single step of the transaction.
+Type Parameters
Parameters
- callback: (() => Promise<T>)
Callback function returning a promise.
+Warning: The callback function should wrap a single call of an async +arangojs method (e.g. a method on a
+Collectionobject of a collection +that is involved in the transaction or thedb.querymethod). +If the callback function is async, only the first promise-returning (or +async) method call will be executed as part of the transaction. See the +examples below for how to avoid common mistakes when using this method.Note: Avoid defining the callback as an async function if possible +as arangojs will throw an error if the callback did not return a promise. +Async functions will return an empty promise by default, making it harder +to notice if you forgot to return something from the callback.
+Note: Although almost anything can be wrapped in a callback and passed +to this method, that does not guarantee ArangoDB can actually do it in a +transaction. Refer to the ArangoDB documentation if you are unsure whether +a given operation can be executed as part of a transaction. Generally any +modification or retrieval of data is eligible but modifications of +collections or databases are not.
+
Returns Promise<T>
Example
+const db = new Database();
const vertices = db.collection("vertices");
const edges = db.collection("edges");
const trx = await db.beginTransaction({ write: [vertices, edges] });
// The following code will be part of the transaction
const left = await trx.step(() => vertices.save({ label: "left" }));
const right = await trx.step(() => vertices.save({ label: "right" }));
// Results from preceding actions can be used normally
await trx.step(() => edges.save({
_from: left._id,
_to: right._id,
data: "potato"
}));
// Transaction must be committed for changes to take effected
// Always call either trx.commit or trx.abort to end a transaction
await trx.commit(); +Example
+// BAD! If the callback is an async function it must only use await once!
await trx.step(async () => {
await collection.save(data);
await collection.save(moreData); // WRONG
});
// BAD! Callback function must use only one arangojs call!
await trx.step(() => {
return collection.save(data)
.then(() => collection.save(moreData)); // WRONG
});
// BETTER: Wrap every arangojs method call that should be part of the
// transaction in a separate `trx.step` call
await trx.step(() => collection.save(data));
await trx.step(() => collection.save(moreData)); +Example
+// BAD! If the callback is an async function it must not await before
// calling an arangojs method!
await trx.step(async () => {
await doSomethingElse();
return collection.save(data); // WRONG
});
// BAD! Any arangojs inside the callback must not happen inside a promise
// method!
await trx.step(() => {
return doSomethingElse()
.then(() => collection.save(data)); // WRONG
});
// BETTER: Perform any async logic needed outside the `trx.step` call
await doSomethingElse();
await trx.step(() => collection.save(data));
// OKAY: You can perform async logic in the callback after the arangojs
// method call as long as it does not involve additional arangojs method
// calls, but this makes it easy to make mistakes later
await trx.step(async () => {
await collection.save(data);
await doSomethingDifferent(); // no arangojs method calls allowed
}); +Example
+// BAD! The callback should not use any functions that themselves use any
// arangojs methods!
async function saveSomeData() {
await collection.save(data);
await collection.save(moreData);
}
await trx.step(() => saveSomeData()); // WRONG
// BETTER: Pass the transaction to functions that need to call arangojs
// methods inside a transaction
async function saveSomeData(trx) {
await trx.step(() => collection.save(data));
await trx.step(() => collection.save(moreData));
}
await saveSomeData(); // no `trx.step` call needed +Example
+// BAD! You must wait for the promise to resolve (or await on the
// `trx.step` call) before calling `trx.step` again!
trx.step(() => collection.save(data)); // WRONG
await trx.step(() => collection.save(moreData));
// BAD! The trx.step callback can not make multiple calls to async arangojs
// methods, not even using Promise.all!
await trx.step(() => Promise.all([ // WRONG
collection.save(data),
collection.save(moreData),
]));
// BAD! Multiple `trx.step` calls can not run in parallel!
await Promise.all([ // WRONG
trx.step(() => collection.save(data)),
trx.step(() => collection.save(moreData)),
]));
// BETTER: Always call `trx.step` sequentially, one after the other
await trx.step(() => collection.save(data));
await trx.step(() => collection.save(moreData));
// OKAY: The then callback can be used if async/await is not available
trx.step(() => collection.save(data))
.then(() => trx.step(() => collection.save(moreData))); +Example
+// BAD! The callback will return an empty promise that resolves before
// the inner arangojs method call has even talked to ArangoDB!
await trx.step(async () => {
collection.save(data); // WRONG
});
// BETTER: Use an arrow function so you don't forget to return
await trx.step(() => collection.save(data));
// OKAY: Remember to always return when using a function body
await trx.step(() => {
return collection.save(data); // easy to forget!
});
// OKAY: You do not have to use arrow functions but it helps
await trx.step(function () {
return collection.save(data);
}); +Example
+// BAD! You can not pass promises instead of a callback!
await trx.step(collection.save(data)); // WRONG
// BETTER: Wrap the code in a function and pass the function instead
await trx.step(() => collection.save(data)); +Example
+// WORSE: Calls to non-async arangojs methods don't need to be performed
// as part of a transaction
const collection = await trx.step(() => db.collection("my-documents"));
// BETTER: If an arangojs method is not async and doesn't return promises,
// call it without `trx.step`
const collection = db.collection("my-documents"); +- callback: (() => Promise<T>)
Returns Promise<T>
- step: (<T>(callback) => Promise<T>)
Optionaloptions: TransactionOptionsOptions for the transaction.
+
Returns Promise<T>
Example
+const vertices = db.collection("vertices");
const edges = db.collection("edges");
await db.withTransaction(
{
read: ["vertices"],
write: [edges] // collection instances can be passed directly
},
async (step) => {
const start = await step(() => vertices.document("a"));
const end = await step(() => vertices.document("b"));
await step(() => edges.save({ _from: start._id, _to: end._id }));
}
); +- collections: TransactionCollections
- with
Transaction<T>(collections, callback, options?): Promise<T> Begins and commits a transaction using the given callback. Individual +requests that are part of the transaction need to be wrapped in the step +function passed into the callback. If the promise returned by the callback +is rejected, the transaction will be aborted.
+Collections can be specified as collection names (strings) or objects +implementing the collection.ArangoCollection interface:
+Collection, +graph.GraphVertexCollection, graph.GraphEdgeCollection as well as +(in TypeScript) collection.DocumentCollection and collection.EdgeCollection.Type Parameters
Parameters
- collections: (string | ArangoCollection)[]
Collections that can be read from and written to +during the transaction.
+ - callback: ((step) => Promise<T>)
Callback function executing the transaction steps.
+- (step): Promise<T>
Parameters
- step: (<T>(callback) => Promise<T>)
- <T>(callback): Promise<T>
Executes the given function locally as a single step of the transaction.
+Type Parameters
Parameters
- callback: (() => Promise<T>)
Callback function returning a promise.
+Warning: The callback function should wrap a single call of an async +arangojs method (e.g. a method on a
+Collectionobject of a collection +that is involved in the transaction or thedb.querymethod). +If the callback function is async, only the first promise-returning (or +async) method call will be executed as part of the transaction. See the +examples below for how to avoid common mistakes when using this method.Note: Avoid defining the callback as an async function if possible +as arangojs will throw an error if the callback did not return a promise. +Async functions will return an empty promise by default, making it harder +to notice if you forgot to return something from the callback.
+Note: Although almost anything can be wrapped in a callback and passed +to this method, that does not guarantee ArangoDB can actually do it in a +transaction. Refer to the ArangoDB documentation if you are unsure whether +a given operation can be executed as part of a transaction. Generally any +modification or retrieval of data is eligible but modifications of +collections or databases are not.
+
Returns Promise<T>
Example
+const db = new Database();
const vertices = db.collection("vertices");
const edges = db.collection("edges");
const trx = await db.beginTransaction({ write: [vertices, edges] });
// The following code will be part of the transaction
const left = await trx.step(() => vertices.save({ label: "left" }));
const right = await trx.step(() => vertices.save({ label: "right" }));
// Results from preceding actions can be used normally
await trx.step(() => edges.save({
_from: left._id,
_to: right._id,
data: "potato"
}));
// Transaction must be committed for changes to take effected
// Always call either trx.commit or trx.abort to end a transaction
await trx.commit(); +Example
+// BAD! If the callback is an async function it must only use await once!
await trx.step(async () => {
await collection.save(data);
await collection.save(moreData); // WRONG
});
// BAD! Callback function must use only one arangojs call!
await trx.step(() => {
return collection.save(data)
.then(() => collection.save(moreData)); // WRONG
});
// BETTER: Wrap every arangojs method call that should be part of the
// transaction in a separate `trx.step` call
await trx.step(() => collection.save(data));
await trx.step(() => collection.save(moreData)); +Example
+// BAD! If the callback is an async function it must not await before
// calling an arangojs method!
await trx.step(async () => {
await doSomethingElse();
return collection.save(data); // WRONG
});
// BAD! Any arangojs inside the callback must not happen inside a promise
// method!
await trx.step(() => {
return doSomethingElse()
.then(() => collection.save(data)); // WRONG
});
// BETTER: Perform any async logic needed outside the `trx.step` call
await doSomethingElse();
await trx.step(() => collection.save(data));
// OKAY: You can perform async logic in the callback after the arangojs
// method call as long as it does not involve additional arangojs method
// calls, but this makes it easy to make mistakes later
await trx.step(async () => {
await collection.save(data);
await doSomethingDifferent(); // no arangojs method calls allowed
}); +Example
+// BAD! The callback should not use any functions that themselves use any
// arangojs methods!
async function saveSomeData() {
await collection.save(data);
await collection.save(moreData);
}
await trx.step(() => saveSomeData()); // WRONG
// BETTER: Pass the transaction to functions that need to call arangojs
// methods inside a transaction
async function saveSomeData(trx) {
await trx.step(() => collection.save(data));
await trx.step(() => collection.save(moreData));
}
await saveSomeData(); // no `trx.step` call needed +Example
+// BAD! You must wait for the promise to resolve (or await on the
// `trx.step` call) before calling `trx.step` again!
trx.step(() => collection.save(data)); // WRONG
await trx.step(() => collection.save(moreData));
// BAD! The trx.step callback can not make multiple calls to async arangojs
// methods, not even using Promise.all!
await trx.step(() => Promise.all([ // WRONG
collection.save(data),
collection.save(moreData),
]));
// BAD! Multiple `trx.step` calls can not run in parallel!
await Promise.all([ // WRONG
trx.step(() => collection.save(data)),
trx.step(() => collection.save(moreData)),
]));
// BETTER: Always call `trx.step` sequentially, one after the other
await trx.step(() => collection.save(data));
await trx.step(() => collection.save(moreData));
// OKAY: The then callback can be used if async/await is not available
trx.step(() => collection.save(data))
.then(() => trx.step(() => collection.save(moreData))); +Example
+// BAD! The callback will return an empty promise that resolves before
// the inner arangojs method call has even talked to ArangoDB!
await trx.step(async () => {
collection.save(data); // WRONG
});
// BETTER: Use an arrow function so you don't forget to return
await trx.step(() => collection.save(data));
// OKAY: Remember to always return when using a function body
await trx.step(() => {
return collection.save(data); // easy to forget!
});
// OKAY: You do not have to use arrow functions but it helps
await trx.step(function () {
return collection.save(data);
}); +Example
+// BAD! You can not pass promises instead of a callback!
await trx.step(collection.save(data)); // WRONG
// BETTER: Wrap the code in a function and pass the function instead
await trx.step(() => collection.save(data)); +Example
+// WORSE: Calls to non-async arangojs methods don't need to be performed
// as part of a transaction
const collection = await trx.step(() => db.collection("my-documents"));
// BETTER: If an arangojs method is not async and doesn't return promises,
// call it without `trx.step`
const collection = db.collection("my-documents"); +- callback: (() => Promise<T>)
Returns Promise<T>
- step: (<T>(callback) => Promise<T>)
Optionaloptions: TransactionOptionsOptions for the transaction.
+
Returns Promise<T>
Example
+const vertices = db.collection("vertices");
const edges = db.collection("edges");
await db.withTransaction(
[
"vertices",
edges, // collection instances can be passed directly
],
async (step) => {
const start = await step(() => vertices.document("a"));
const end = await step(() => vertices.document("b"));
await step(() => edges.save({ _from: start._id, _to: end._id }));
}
); +- collections: (string | ArangoCollection)[]
- with
Transaction<T>(collection, callback, options?): Promise<T> Begins and commits a transaction using the given callback. Individual +requests that are part of the transaction need to be wrapped in the step +function passed into the callback. If the promise returned by the callback +is rejected, the transaction will be aborted.
+The Collection can be specified as a collection name (string) or an object +implementing the collection.ArangoCollection interface:
+Collection, +graph.GraphVertexCollection, graph.GraphEdgeCollection as well as +(in TypeScript) collection.DocumentCollection and collection.EdgeCollection.Type Parameters
Parameters
- collection: string | ArangoCollection
A collection that can be read from and written to +during the transaction.
+ - callback: ((step) => Promise<T>)
Callback function executing the transaction steps.
+- (step): Promise<T>
Parameters
- step: (<T>(callback) => Promise<T>)
- <T>(callback): Promise<T>
Executes the given function locally as a single step of the transaction.
+Type Parameters
Parameters
- callback: (() => Promise<T>)
Callback function returning a promise.
+Warning: The callback function should wrap a single call of an async +arangojs method (e.g. a method on a
+Collectionobject of a collection +that is involved in the transaction or thedb.querymethod). +If the callback function is async, only the first promise-returning (or +async) method call will be executed as part of the transaction. See the +examples below for how to avoid common mistakes when using this method.Note: Avoid defining the callback as an async function if possible +as arangojs will throw an error if the callback did not return a promise. +Async functions will return an empty promise by default, making it harder +to notice if you forgot to return something from the callback.
+Note: Although almost anything can be wrapped in a callback and passed +to this method, that does not guarantee ArangoDB can actually do it in a +transaction. Refer to the ArangoDB documentation if you are unsure whether +a given operation can be executed as part of a transaction. Generally any +modification or retrieval of data is eligible but modifications of +collections or databases are not.
+
Returns Promise<T>
Example
+const db = new Database();
const vertices = db.collection("vertices");
const edges = db.collection("edges");
const trx = await db.beginTransaction({ write: [vertices, edges] });
// The following code will be part of the transaction
const left = await trx.step(() => vertices.save({ label: "left" }));
const right = await trx.step(() => vertices.save({ label: "right" }));
// Results from preceding actions can be used normally
await trx.step(() => edges.save({
_from: left._id,
_to: right._id,
data: "potato"
}));
// Transaction must be committed for changes to take effected
// Always call either trx.commit or trx.abort to end a transaction
await trx.commit(); +Example
+// BAD! If the callback is an async function it must only use await once!
await trx.step(async () => {
await collection.save(data);
await collection.save(moreData); // WRONG
});
// BAD! Callback function must use only one arangojs call!
await trx.step(() => {
return collection.save(data)
.then(() => collection.save(moreData)); // WRONG
});
// BETTER: Wrap every arangojs method call that should be part of the
// transaction in a separate `trx.step` call
await trx.step(() => collection.save(data));
await trx.step(() => collection.save(moreData)); +Example
+// BAD! If the callback is an async function it must not await before
// calling an arangojs method!
await trx.step(async () => {
await doSomethingElse();
return collection.save(data); // WRONG
});
// BAD! Any arangojs inside the callback must not happen inside a promise
// method!
await trx.step(() => {
return doSomethingElse()
.then(() => collection.save(data)); // WRONG
});
// BETTER: Perform any async logic needed outside the `trx.step` call
await doSomethingElse();
await trx.step(() => collection.save(data));
// OKAY: You can perform async logic in the callback after the arangojs
// method call as long as it does not involve additional arangojs method
// calls, but this makes it easy to make mistakes later
await trx.step(async () => {
await collection.save(data);
await doSomethingDifferent(); // no arangojs method calls allowed
}); +Example
+// BAD! The callback should not use any functions that themselves use any
// arangojs methods!
async function saveSomeData() {
await collection.save(data);
await collection.save(moreData);
}
await trx.step(() => saveSomeData()); // WRONG
// BETTER: Pass the transaction to functions that need to call arangojs
// methods inside a transaction
async function saveSomeData(trx) {
await trx.step(() => collection.save(data));
await trx.step(() => collection.save(moreData));
}
await saveSomeData(); // no `trx.step` call needed +Example
+// BAD! You must wait for the promise to resolve (or await on the
// `trx.step` call) before calling `trx.step` again!
trx.step(() => collection.save(data)); // WRONG
await trx.step(() => collection.save(moreData));
// BAD! The trx.step callback can not make multiple calls to async arangojs
// methods, not even using Promise.all!
await trx.step(() => Promise.all([ // WRONG
collection.save(data),
collection.save(moreData),
]));
// BAD! Multiple `trx.step` calls can not run in parallel!
await Promise.all([ // WRONG
trx.step(() => collection.save(data)),
trx.step(() => collection.save(moreData)),
]));
// BETTER: Always call `trx.step` sequentially, one after the other
await trx.step(() => collection.save(data));
await trx.step(() => collection.save(moreData));
// OKAY: The then callback can be used if async/await is not available
trx.step(() => collection.save(data))
.then(() => trx.step(() => collection.save(moreData))); +Example
+// BAD! The callback will return an empty promise that resolves before
// the inner arangojs method call has even talked to ArangoDB!
await trx.step(async () => {
collection.save(data); // WRONG
});
// BETTER: Use an arrow function so you don't forget to return
await trx.step(() => collection.save(data));
// OKAY: Remember to always return when using a function body
await trx.step(() => {
return collection.save(data); // easy to forget!
});
// OKAY: You do not have to use arrow functions but it helps
await trx.step(function () {
return collection.save(data);
}); +Example
+// BAD! You can not pass promises instead of a callback!
await trx.step(collection.save(data)); // WRONG
// BETTER: Wrap the code in a function and pass the function instead
await trx.step(() => collection.save(data)); +Example
+// WORSE: Calls to non-async arangojs methods don't need to be performed
// as part of a transaction
const collection = await trx.step(() => db.collection("my-documents"));
// BETTER: If an arangojs method is not async and doesn't return promises,
// call it without `trx.step`
const collection = db.collection("my-documents"); +- callback: (() => Promise<T>)
Returns Promise<T>
- step: (<T>(callback) => Promise<T>)
Optionaloptions: TransactionOptionsOptions for the transaction.
+
Returns Promise<T>
Example
+const vertices = db.collection("vertices");
const start = vertices.document("a");
const end = vertices.document("b");
const edges = db.collection("edges");
await db.withTransaction(
edges, // collection instances can be passed directly
async (step) => {
await step(() => edges.save({ _from: start._id, _to: end._id }));
}
); +- collection: string | ArangoCollection
Class ArangoError
Represents an error returned by ArangoDB.
+Hierarchy
- Error
- ArangoError
Index
Properties
Methods
Properties
code
HTTP status code included in the server error response object.
+error
ArangoDB error code.
+ +name
response
Server response object.
+Static Optional prepare
Optional override for formatting stack traces
+Type declaration
- (err, stackTraces): any
Parameters
- err: Error
- stackTraces: CallSite[]
Returns any
Static stack
Methods
toJSON
Static capture
Class HttpError
Represents a plain HTTP error response.
+Hierarchy
- Error
- HttpError
Index
Properties
Methods
Properties
code
HTTP status code of the server response.
+name
response
Server response object.
+Static Optional prepare
Optional override for formatting stack traces
+Type declaration
- (err, stackTraces): any
Parameters
- err: Error
- stackTraces: CallSite[]
Returns any
Static stack
Methods
toJSON
Static capture
Class Graph
Represents a graph in a database.Database.
+Accessors
name
- get name(): string
Name of the graph.
+Returns string
Methods
add
- add
Edge Definition(edgeDefinition, options?): Promise<GraphInfo> Adds an edge definition to this graph.
+Parameters
- edgeDefinition: EdgeDefinitionOptions
Definition of a relation in this graph.
+ - options: AddEdgeDefinitionOptions = {}
Returns Promise<GraphInfo>
Example
+const db = new Database();
const graph = db.graph("some-graph");
await graph.addEdgeDefinition({
collection: "edges",
from: ["start-vertices"],
to: ["end-vertices"],
});
// The edge definition has been added to the graph +- edgeDefinition: EdgeDefinitionOptions
add
- add
Vertex Collection(collection, options?): Promise<GraphInfo> Adds the given collection to this graph as a vertex collection.
+Parameters
- collection: string | ArangoCollection
Collection to add to the graph.
+ - options: AddVertexCollectionOptions = {}
Returns Promise<GraphInfo>
Example
+const db = new Database();
const graph = db.graph("some-graph");
await graph.addVertexCollection("more-vertices");
// The collection "more-vertices" has been added to the graph
const extra = db.collection("extra-vertices");
await graph.addVertexCollection(extra);
// The collection "extra-vertices" has been added to the graph +- collection: string | ArangoCollection
create
- create(edgeDefinitions, options?): Promise<GraphInfo>
Creates a graph with the given
+edgeDefinitionsandoptionsfor this +graph's name.Parameters
- edgeDefinitions: EdgeDefinitionOptions[]
Definitions for the relations of the graph.
+ - options: CreateGraphOptions = {}
Options for creating the graph.
+
Returns Promise<GraphInfo>
Example
+const db = new Database();
const graph = db.graph("some-graph");
const info = await graph.create([
{
collection: "edges",
from: ["start-vertices"],
to: ["end-vertices"],
},
]);
// graph now exists +- edgeDefinitions: EdgeDefinitionOptions[]
drop
- drop(dropCollections?): Promise<boolean>
Deletes the graph from the database.
+Parameters
- dropCollections: boolean = false
If set to
+true, the collections associated with +the graph will also be deleted.
Returns Promise<boolean>
Example
+const db = new Database();
const graph = db.graph("some-graph");
await graph.drop();
// the graph "some-graph" no longer exists +- dropCollections: boolean = false
edge
- edge
Collection<T>(collection): GraphEdgeCollection<T> Returns a graph.GraphEdgeCollection instance for the given collection +name representing the collection in this graph.
+Type Parameters
Parameters
- collection: string | ArangoCollection
Name of the edge collection.
+
Returns GraphEdgeCollection<T>
Example
+const db = new Database();
const graph = db.graph("some-graph");
const info = await graph.create([
{
collection: "edges",
from: ["start-vertices"],
to: ["end-vertices"],
},
]);
const graphEdgeCollection = graph.edgeCollection("edges");
// Access the underlying EdgeCollection API:
const edgeCollection = graphEdgeCollection.collection; +- collection: string | ArangoCollection
edge
- edge
Collections(): Promise<GraphEdgeCollection<any>[]> Fetches all edge collections of this graph from the database and returns +an array of graph.GraphEdgeCollection instances.
+See also graph.Graph#listEdgeCollections.
+Returns Promise<GraphEdgeCollection<any>[]>
Example
+const db = new Database();
const graph = db.graph("some-graph");
const info = await graph.create([
{
collection: "edges",
from: ["start-vertices"],
to: ["end-vertices"],
},
]);
const graphEdgeCollections = await graph.edgeCollections();
for (const collection of graphEdgeCollection) {
console.log(collection.name);
// "edges"
} +
exists
get
list
- list
Edge Collections(): Promise<string[]> Fetches all edge collections of this graph from the database and returns +an array of their names.
+See also graph.Graph#edgeCollections.
+Returns Promise<string[]>
Example
+const db = new Database();
const graph = db.graph("some-graph");
const info = await graph.create([
{
collection: "edges",
from: ["start-vertices"],
to: ["end-vertices"],
},
]);
const edgeCollectionNames = await graph.listEdgeCollections();
// ["edges"] +
list
- list
Vertex Collections(): Promise<string[]> Fetches all vertex collections of this graph from the database and returns +an array of their names.
+See also graph.Graph#vertexCollections.
+Returns Promise<string[]>
Example
+const db = new Database();
const graph = db.graph("some-graph");
const info = await graph.create([
{
collection: "edges",
from: ["start-vertices"],
to: ["end-vertices"],
},
]);
const vertexCollectionNames = await graph.listVertexCollections();
// ["start-vertices", "end-vertices"] +
remove
- remove
Edge Definition(collection, dropCollection?): Promise<GraphInfo> Removes the edge definition for the given edge collection from this graph.
+Parameters
- collection: string | ArangoCollection
Edge collection for which to remove the definition.
+ - dropCollection: boolean = false
If set to
+true, the collection will also be +deleted from the database.
Returns Promise<GraphInfo>
Example
+const db = new Database();
const graph = db.graph("some-graph");
const info = await graph.create([
{
collection: "edges",
from: ["start-vertices"],
to: ["end-vertices"],
},
]);
await graph.removeEdgeDefinition("edges");
// The edge definition for "edges" has been replaced +- collection: string | ArangoCollection
remove
- remove
Vertex Collection(collection, dropCollection?): Promise<GraphInfo> Removes the given collection from this graph as a vertex collection.
+Parameters
- collection: string | ArangoCollection
Collection to remove from the graph.
+ - dropCollection: boolean = false
If set to
+true, the collection will also be +deleted from the database.
Returns Promise<GraphInfo>
Example
+const db = new Database();
const graph = db.graph("some-graph");
const info = await graph.create([
{
collection: "edges",
from: ["start-vertices"],
to: ["end-vertices"],
},
]);
await graph.removeVertexCollection("start-vertices");
// The collection "start-vertices" is no longer part of the graph. +- collection: string | ArangoCollection
replace
- replace
Edge Definition(edgeDefinition, options?): Promise<GraphInfo> Replaces an edge definition in this graph. The existing edge definition +for the given edge collection will be overwritten.
+Parameters
- edgeDefinition: EdgeDefinitionOptions
Definition of a relation in this graph.
+ Optionaloptions: ReplaceEdgeDefinitionOptions
Returns Promise<GraphInfo>
Example
+const db = new Database();
const graph = db.graph("some-graph");
const info = await graph.create([
{
collection: "edges",
from: ["start-vertices"],
to: ["end-vertices"],
},
]);
await graph.replaceEdgeDefinition({
collection: "edges",
from: ["start-vertices"],
to: ["other-vertices"],
});
// The edge definition for "edges" has been replaced +- edgeDefinition: EdgeDefinitionOptions
- replace
Edge Definition(collection, edgeDefinition, options?): Promise<GraphInfo> Replaces an edge definition in this graph. The existing edge definition +for the given edge collection will be overwritten.
+Parameters
- collection: string | ArangoCollection
Edge collection for which to replace the definition.
+ - edgeDefinition: EdgeDefinitionOptions
Definition of a relation in this graph.
+ Optionaloptions: ReplaceEdgeDefinitionOptions
Returns Promise<GraphInfo>
Example
+const db = new Database();
const graph = db.graph("some-graph");
const info = await graph.create([
{
collection: "edges",
from: ["start-vertices"],
to: ["end-vertices"],
},
]);
await graph.replaceEdgeDefinition("edges", {
collection: "edges",
from: ["start-vertices"],
to: ["other-vertices"],
});
// The edge definition for "edges" has been replaced +- collection: string | ArangoCollection
vertex
- vertex
Collection<T>(collection): GraphVertexCollection<T> Returns a graph.GraphVertexCollection instance for the given collection +name representing the collection in this graph.
+Type Parameters
Parameters
- collection: string | ArangoCollection
Name of the vertex collection.
+
Returns GraphVertexCollection<T>
- collection: string | ArangoCollection
vertex
- vertex
Collections(): Promise<GraphVertexCollection<any>[]> Fetches all vertex collections of this graph from the database and returns +an array of graph.GraphVertexCollection instances.
+See also graph.Graph#listVertexCollections.
+Returns Promise<GraphVertexCollection<any>[]>
Example
+const db = new Database();
const graph = db.graph("some-graph");
const info = await graph.create([
{
collection: "edges",
from: ["start-vertices"],
to: ["end-vertices"],
},
]);
const vertexCollections = await graph.vertexCollections();
for (const vertexCollection of vertexCollections) {
console.log(vertexCollection.name);
// "start-vertices"
// "end-vertices"
} +
Class GraphEdgeCollection<T>
Represents a collection.EdgeCollection of edges in a graph.Graph.
+Type Parameters
Implements
Index
Accessors
Methods
Accessors
collection
- get collection(): EdgeCollection<T, T>
A collection.EdgeCollection instance for this edge collection.
+Returns EdgeCollection<T, T>
graph
- get graph(): Graph
The graph.Graph instance this edge collection is bound to.
+Returns Graph
name
- get name(): string
Name of the collection.
+Returns string
Methods
edge
- edge(selector, options?): Promise<Edge<T>>
Retrieves the edge matching the given key or id.
+Throws an exception when passed a edge or
+_idfrom a different +collection, or if the edge does not exist.Parameters
- selector: DocumentSelector
Document
+_key,_idor object with either of those +properties (e.g. a edge from this collection). Optionaloptions: GraphCollectionReadOptionsOptions for retrieving the edge.
+
Returns Promise<Edge<T>>
Example
+const graph = db.graph("some-graph");
const collection = graph.edgeCollection("friends")
try {
const edge = await collection.edge("abc123");
console.log(edge);
} catch (e: any) {
console.error("Could not find edge");
} +Example
+const graph = db.graph("some-graph");
const collection = graph.edgeCollection("friends")
const edge = await collection.edge("abc123", { graceful: true });
if (edge) {
console.log(edge);
} else {
console.error("Edge does not exist");
} +- selector: DocumentSelector
- edge(selector, graceful): Promise<Edge<T>>
Retrieves the edge matching the given key or id.
+Throws an exception when passed a edge or
+_idfrom a different +collection, or if the edge does not exist.Parameters
- selector: DocumentSelector
Document
+_key,_idor object with either of those +properties (e.g. a edge from this collection). - graceful: boolean
If set to
+true,nullis returned instead of an +exception being thrown if the edge does not exist.
Returns Promise<Edge<T>>
Example
+const graph = db.graph("some-graph");
const collection = graph.edgeCollection("friends")
try {
const edge = await collection.edge("abc123", false);
console.log(edge);
} catch (e: any) {
console.error("Could not find edge");
} +Example
+const graph = db.graph("some-graph");
const collection = graph.edgeCollection("friends")
const edge = await collection.edge("abc123", true);
if (edge) {
console.log(edge);
} else {
console.error("Edge does not exist");
} +- selector: DocumentSelector
edge
- edge
Exists(selector): Promise<boolean> Checks whether a edge matching the given key or id exists in this +collection.
+Throws an exception when passed a edge or
+_idfrom a different +collection.Parameters
- selector: DocumentSelector
Document
+_key,_idor object with either of those +properties (e.g. a edge from this collection).
Returns Promise<boolean>
Example
+const graph = db.graph("some-graph");
const collection = graph.edgeCollection("friends")
const exists = await collection.edgeExists("abc123");
if (!exists) {
console.log("Edge does not exist");
} +- selector: DocumentSelector
remove
- remove(selector, options?): Promise<DocumentMetadata & {
old?: Edge<T>;
}> Removes an existing edge from the collection.
+Throws an exception when passed a edge or
+_idfrom a different +collection.Parameters
- selector: DocumentSelector
Document
+_key,_idor object with either of those +properties (e.g. a edge from this collection). Optionaloptions: GraphCollectionRemoveOptionsOptions for removing the edge.
+
Returns Promise<DocumentMetadata & {
old?: Edge<T>;
}>Example
+const db = new Database();
const collection = db.collection("friends");
const doc = await collection.edge("musadir");
await collection.remove(doc);
// edge with key "musadir" deleted +- selector: DocumentSelector
replace
- replace(selector, newValue, options?): Promise<DocumentMetadata & {
new?: Edge<T>;
old?: Edge<T>;
}> Replaces an existing edge in the collection.
+Throws an exception when passed a edge or
+_idfrom a different +collection.Parameters
- selector: DocumentSelector
Document
+_key,_idor object with either of those +properties (e.g. a edge from this collection). - newValue: EdgeData<T>
Optionaloptions: GraphCollectionReplaceOptionsOptions for replacing the edge.
+
Returns Promise<DocumentMetadata & {
new?: Edge<T>;
old?: Edge<T>;
}>Example
+const db = new Database();
const collection = db.collection("friends");
await collection.save(
{
_key: "musadir",
_from: "users/rana",
_to: "users/mudasir",
active: true,
best: true
}
);
const result = await collection.replace(
"musadir",
{ active: false },
{ returnNew: true }
);
console.log(result.new.active, result.new.best); // false undefined +- selector: DocumentSelector
save
- save(data, options?): Promise<DocumentMetadata & {
new?: Edge<T>;
}> Inserts a new edge with the given
+datainto the collection.Parameters
- data: EdgeData<T>
The contents of the new edge.
+ Optionaloptions: GraphCollectionInsertOptionsOptions for inserting the edge.
+
Returns Promise<DocumentMetadata & {
new?: Edge<T>;
}>Example
+const db = new Database();
const collection = db.collection("friends");
const result = await collection.save(
{ _from: "users/rana", _to: "users/mudasir", active: false },
{ returnNew: true }
); +- data: EdgeData<T>
update
- update(selector, newValue, options?): Promise<DocumentMetadata & {
new?: Edge<T>;
old?: Edge<T>;
}> Updates an existing edge in the collection.
+Throws an exception when passed a edge or
+_idfrom a different +collection.Parameters
- selector: DocumentSelector
Document
+_key,_idor object with either of those +properties (e.g. a edge from this collection). - newValue: Patch<EdgeData<T>>
Optionaloptions: GraphCollectionReplaceOptionsOptions for updating the edge.
+
Returns Promise<DocumentMetadata & {
new?: Edge<T>;
old?: Edge<T>;
}>Example
+const db = new Database();
const collection = db.collection("friends");
await collection.save(
{
_key: "musadir",
_from: "users/rana",
_to: "users/mudasir",
active: true,
best: true
}
);
const result = await collection.update(
"musadir",
{ active: false },
{ returnNew: true }
);
console.log(result.new.active, result.new.best); // false true +- selector: DocumentSelector
Class GraphVertexCollection<T>
Represents a collection.DocumentCollection of vertices in a graph.Graph.
+Type Parameters
Implements
Index
Accessors
Methods
Accessors
collection
- get collection(): DocumentCollection<T, T>
A collection.DocumentCollection instance for this vertex collection.
+Returns DocumentCollection<T, T>
graph
- get graph(): Graph
The graph.Graph instance this vertex collection is bound to.
+Returns Graph
name
- get name(): string
Name of the collection.
+Returns string
Methods
remove
- remove(selector, options?): Promise<DocumentMetadata & {
old?: Document<T>;
}> Removes an existing vertex from the collection.
+Throws an exception when passed a vertex or
+_idfrom a different +collection.Parameters
- selector: DocumentSelector
Document
+_key,_idor object with either of those +properties (e.g. a vertex from this collection). Optionaloptions: GraphCollectionRemoveOptionsOptions for removing the vertex.
+
Returns Promise<DocumentMetadata & {
old?: Document<T>;
}>Example
+const graph = db.graph("some-graph");
const collection = graph.vertexCollection("vertices");
await collection.remove("abc123");
// document with key "abc123" deleted +Example
+const graph = db.graph("some-graph");
const collection = graph.vertexCollection("vertices");
const doc = await collection.vertex("abc123");
await collection.remove(doc);
// document with key "abc123" deleted +- selector: DocumentSelector
replace
- replace(selector, newValue, options?): Promise<DocumentMetadata & {
new?: Document<T>;
old?: Document<T>;
}> Replaces an existing vertex in the collection.
+Throws an exception when passed a vertex or
+_idfrom a different +collection.Parameters
- selector: DocumentSelector
Document
+_key,_idor object with either of those +properties (e.g. a vertex from this collection). - newValue: DocumentData<T>
Optionaloptions: GraphCollectionReplaceOptionsOptions for replacing the vertex.
+
Returns Promise<DocumentMetadata & {
new?: Document<T>;
old?: Document<T>;
}>Example
+const graph = db.graph("some-graph");
const collection = graph.collection("vertices");
await collection.save({ _key: "a", color: "blue", count: 1 });
const result = await collection.replace(
"a",
{ color: "red" },
{ returnNew: true }
);
console.log(result.new.color, result.new.count); // "red" undefined +- selector: DocumentSelector
save
- save(data, options?): Promise<DocumentMetadata & {
new?: Document<T>;
}> Inserts a new vertex with the given
+datainto the collection.Parameters
- data: DocumentData<T>
The contents of the new vertex.
+ Optionaloptions: GraphCollectionInsertOptionsOptions for inserting the vertex.
+
Returns Promise<DocumentMetadata & {
new?: Document<T>;
}>Example
+const graph = db.graph("some-graph");
const collection = graph.vertexCollection("friends");
const result = await collection.save(
{ _key: "a", color: "blue", count: 1 },
{ returnNew: true }
);
console.log(result.new.color, result.new.count); // "blue" 1 +- data: DocumentData<T>
update
- update(selector, newValue, options?): Promise<DocumentMetadata & {
new?: Document<T>;
old?: Document<T>;
}> Updates an existing vertex in the collection.
+Throws an exception when passed a vertex or
+_idfrom a different +collection.Parameters
- selector: DocumentSelector
Document
+_key,_idor object with either of those +properties (e.g. a vertex from this collection). - newValue: Patch<DocumentData<T>>
Optionaloptions: GraphCollectionReplaceOptionsOptions for updating the vertex.
+
Returns Promise<DocumentMetadata & {
new?: Document<T>;
old?: Document<T>;
}>Example
+const graph = db.graph("some-graph");
const collection = graph.collection("vertices");
await collection.save({ _key: "a", color: "blue", count: 1 });
const result = await collection.update(
"a",
{ count: 2 },
{ returnNew: true }
);
console.log(result.new.color, result.new.count); // "blue" 2 +- selector: DocumentSelector
vertex
- vertex(selector, options?): Promise<Document<T>>
Retrieves the vertex matching the given key or id.
+Throws an exception when passed a vertex or
+_idfrom a different +collection.Parameters
- selector: DocumentSelector
Document
+_key,_idor object with either of those +properties (e.g. a vertex from this collection). Optionaloptions: GraphCollectionReadOptionsOptions for retrieving the vertex.
+
Returns Promise<Document<T>>
Example
+const graph = db.graph("some-graph");
const collection = graph.vertexCollection("vertices");
try {
const vertex = await collection.vertex("abc123");
console.log(vertex);
} catch (e: any) {
console.error("Could not find vertex");
} +Example
+const graph = db.graph("some-graph");
const collection = graph.vertexCollection("vertices");
const vertex = await collection.vertex("abc123", { graceful: true });
if (vertex) {
console.log(vertex);
} else {
console.error("Could not find vertex");
} +- selector: DocumentSelector
- vertex(selector, graceful): Promise<Document<T>>
Retrieves the vertex matching the given key or id.
+Throws an exception when passed a vertex or
+_idfrom a different +collection.Parameters
- selector: DocumentSelector
Document
+_key,_idor object with either of those +properties (e.g. a vertex from this collection). - graceful: boolean
If set to
+true,nullis returned instead of an +exception being thrown if the vertex does not exist.
Returns Promise<Document<T>>
Example
+const graph = db.graph("some-graph");
const collection = graph.vertexCollection("vertices");
try {
const vertex = await collection.vertex("abc123", false);
console.log(vertex);
} catch (e: any) {
console.error("Could not find vertex");
} +Example
+const graph = db.graph("some-graph");
const collection = graph.vertexCollection("vertices");
const vertex = await collection.vertex("abc123", true);
if (vertex) {
console.log(vertex);
} else {
console.error("Could not find vertex");
} +- selector: DocumentSelector
vertex
- vertex
Exists(selector): Promise<boolean> Checks whether a vertex matching the given key or id exists in this +collection.
+Throws an exception when passed a vertex or
+_idfrom a different +collection.Parameters
- selector: DocumentSelector
Document
+_key,_idor object with either of those +properties (e.g. a vertex from this collection).
Returns Promise<boolean>
Example
+const graph = db.graph("some-graph");
const collection = graph.vertexCollection("vertices");
const exists = await collection.vertexExists("abc123");
if (!exists) {
console.log("Vertex does not exist");
} +- selector: DocumentSelector
Class Job<T>
Represents an async job in a database.Database.
+Type Parameters
Index
Accessors
Methods
Accessors
id
- get id(): string
The job's ID.
+Returns string
is
- get isLoaded(): boolean
Whether the job's results have been loaded. If set to
+true, the job's +result can be accessed from Job.result.Returns boolean
result
Methods
cancel
delete
get
- get
Completed(): Promise<boolean> Fetches the job's completion state.
+Returns
+trueif the job has completed,falseotherwise.Returns Promise<boolean>
Example
+// poll for the job to complete
while (!(await job.getCompleted())) {
await timeout(1000);
}
// job result is now available and can be loaded
await job.load();
console.log(job.result); +
load
- load(): Promise<undefined | T>
Loads the job's result from the database if it is not already loaded.
+Returns Promise<undefined | T>
Example
+// poll for the job to complete
while (!job.isLoaded) {
await timeout(1000);
const result = await job.load();
console.log(result);
}
// job result is now loaded and can also be accessed from job.result
console.log(job.result); +
Class Route
Represents an arbitrary route relative to an ArangoDB database.
+Methods
delete
- delete(path, search?, headers?): Promise<ArangojsResponse>
Performs a DELETE request against the given path relative to this route +and returns the server response.
+Parameters
- path: string
Path relative to this route.
+ Optionalsearch: Record<string, any> | URLSearchParamsQuery string parameters for this request.
+Optionalheaders: Headers | Record<string, string>Additional headers to send with this request.
+
Returns Promise<ArangojsResponse>
Example
+const db = new Database();
const foxx = db.route("/my-foxx-service");
const res = await foxx.delete("/users/admin"); +- path: string
- delete(search?, headers?): Promise<ArangojsResponse>
Performs a DELETE request against the given path relative to this route +and returns the server response.
+Parameters
Optionalsearch: Record<string, any> | URLSearchParamsQuery string parameters for this request.
+Optionalheaders: Headers | Record<string, string>Additional headers to send with this request.
+
Returns Promise<ArangojsResponse>
Example
+const db = new Database();
const foxx = db.route("/my-foxx-service");
const user = foxx.roue("/users/admin");
const res = await user.delete(); +
get
- get(path, search?, headers?): Promise<ArangojsResponse>
Performs a GET request against the given path relative to this route +and returns the server response.
+Parameters
- path: string
Path relative to this route.
+ Optionalsearch: Record<string, any> | URLSearchParamsQuery string parameters for this request.
+Optionalheaders: Headers | Record<string, string>Additional headers to send with this request.
+
Returns Promise<ArangojsResponse>
Example
+const db = new Database();
const foxx = db.route("/my-foxx-service");
const res = await foxx.get("/users", { offset: 10, limit: 5 }); +- path: string
- get(search?, headers?): Promise<ArangojsResponse>
Performs a GET request against the given path relative to this route +and returns the server response.
+Parameters
Optionalsearch: Record<string, any> | URLSearchParamsQuery string parameters for this request.
+Optionalheaders: Headers | Record<string, string>Additional headers to send with this request.
+
Returns Promise<ArangojsResponse>
Example
+const db = new Database();
const foxx = db.route("/my-foxx-service");
const users = foxx.route("/users");
const res = await users.get({ offset: 10, limit: 5 }); +
head
- head(path, search?, headers?): Promise<ArangojsResponse>
Performs a HEAD request against the given path relative to this route +and returns the server response.
+Parameters
- path: string
Path relative to this route.
+ Optionalsearch: Record<string, any> | URLSearchParamsQuery string parameters for this request.
+Optionalheaders: Headers | Record<string, string>Additional headers to send with this request.
+
Returns Promise<ArangojsResponse>
Example
+const db = new Database();
const foxx = db.route("/my-foxx-service");
const res = await foxx.head("/users", { offset: 10, limit: 5 }); +- path: string
- head(search?, headers?): Promise<ArangojsResponse>
Performs a HEAD request against the given path relative to this route +and returns the server response.
+Parameters
Optionalsearch: Record<string, any> | URLSearchParamsQuery string parameters for this request.
+Optionalheaders: Headers | Record<string, string>Additional headers to send with this request.
+
Returns Promise<ArangojsResponse>
Example
+const db = new Database();
const foxx = db.route("/my-foxx-service");
const users = foxx.route("/users");
const res = await users.head({ offset: 10, limit: 5 }); +
patch
- patch(path, body?, search?, headers?): Promise<ArangojsResponse>
Performs a PATCH request against the given path relative to this route +and returns the server response.
+Parameters
- path: string
Path relative to this route.
+ Optionalbody: anyBody of the request object.
+Optionalsearch: Record<string, any> | URLSearchParamsQuery string parameters for this request.
+Optionalheaders: Headers | Record<string, string>Additional headers to send with this request.
+
Returns Promise<ArangojsResponse>
Example
+const db = new Database();
const foxx = db.route("/my-foxx-service");
const res = await foxx.patch("/users/admin", { password: "admin" }); +- path: string
- patch(body?, search?, headers?): Promise<ArangojsResponse>
Performs a PATCH request against the given path relative to this route +and returns the server response.
+Note:
+bodymust not be astring.Parameters
Optionalbody: anyBody of the request object. Must not be a string.
+Optionalsearch: Record<string, any> | URLSearchParamsQuery string parameters for this request.
+Optionalheaders: Headers | Record<string, string>Additional headers to send with this request.
+
Returns Promise<ArangojsResponse>
Example
+const db = new Database();
const foxx = db.route("/my-foxx-service");
const user = foxx.route("/users/admin")
const res = await user.patch({ password: "admin" }); +
post
- post(path, body?, search?, headers?): Promise<ArangojsResponse>
Performs a POST request against the given path relative to this route +and returns the server response.
+Parameters
- path: string
Path relative to this route.
+ Optionalbody: anyBody of the request object.
+Optionalsearch: Record<string, any> | URLSearchParamsQuery string parameters for this request.
+Optionalheaders: Headers | Record<string, string>Additional headers to send with this request.
+
Returns Promise<ArangojsResponse>
Example
+const db = new Database();
const foxx = db.route("/my-foxx-service");
const res = await foxx.post("/users", {
username: "admin",
password: "hunter2"
}); +- path: string
- post(body?, search?, headers?): Promise<ArangojsResponse>
Performs a POST request against the given path relative to this route +and returns the server response.
+Note:
+bodymust not be astring.Parameters
Optionalbody: anyBody of the request object. Must not be a string.
+Optionalsearch: Record<string, any> | URLSearchParamsQuery string parameters for this request.
+Optionalheaders: Headers | Record<string, string>Additional headers to send with this request.
+
Returns Promise<ArangojsResponse>
Example
+const db = new Database();
const foxx = db.route("/my-foxx-service");
const users = foxx.route("/users");
const res = await users.post({
username: "admin",
password: "hunter2"
}); +
put
- put(path, body?, search?, headers?): Promise<ArangojsResponse>
Performs a PUT request against the given path relative to this route +and returns the server response.
+Parameters
- path: string
Path relative to this route.
+ Optionalbody: anyBody of the request object.
+Optionalsearch: Record<string, any> | URLSearchParamsQuery string parameters for this request.
+Optionalheaders: Headers | Record<string, string>Additional headers to send with this request.
+
Returns Promise<ArangojsResponse>
Example
+const db = new Database();
const foxx = db.route("/my-foxx-service");
const res = await foxx.put("/users/admin/password", { password: "admin" }); +- path: string
- put(body?, search?, headers?): Promise<ArangojsResponse>
Performs a PUT request against the given path relative to this route +and returns the server response.
+Note:
+bodymust not be astring.Parameters
Optionalbody: anyBody of the request object. Must not be a string.
+Optionalsearch: Record<string, any> | URLSearchParamsQuery string parameters for this request.
+Optionalheaders: Headers | Record<string, string>Additional headers to send with this request.
+
Returns Promise<ArangojsResponse>
Example
+const db = new Database();
const foxx = db.route("/my-foxx-service");
const password = foxx.route("/users/admin/password");
const res = await password.put({ password: "admin" }); +
request
- request(options?): Promise<ArangojsResponse>
Performs an arbitrary HTTP request relative to this route and returns the +server response.
+Parameters
Optionaloptions: RequestOptionsOptions for performing the request.
+
Returns Promise<ArangojsResponse>
Example
+const db = new Database();
const foxx = db.route("/my-foxx-service");
const res = await foxx.request({
method: "POST",
path: "/users",
body: {
username: "admin",
password: "hunter2"
}
}); +
route
- route(path, headers?): Route
Creates a new route relative to this route that inherits any of its default +HTTP headers.
+Parameters
- path: string
Path relative to this route.
+ Optionalheaders: Headers | Record<string, string>Additional headers that will be sent with each request.
+
Returns Route
Example
+const db = new Database();
const foxx = db.route("/my-foxx-service");
const users = foxx.route("/users"); +- path: string
Class Transaction
Represents a streaming transaction in a database.Database.
+Accessors
id
- get id(): string
Unique identifier of this transaction.
+ +Returns string
Methods
abort
- abort(options?): Promise<TransactionStatus>
Attempts to abort the transaction to the databases.
+Parameters
- options: TransactionAbortOptions = {}
Options for aborting the transaction.
+
Returns Promise<TransactionStatus>
Example
+const db = new Database();
const col = db.collection("some-collection");
const trx = db.beginTransaction(col);
await trx.step(() => col.save({ hello: "world" }));
const result = await trx.abort();
// result indicates the updated transaction status +- options: TransactionAbortOptions = {}
commit
- commit(options?): Promise<TransactionStatus>
Attempts to commit the transaction to the databases.
+Parameters
- options: TransactionCommitOptions = {}
Options for comitting the transaction.
+
Returns Promise<TransactionStatus>
Example
+const db = new Database();
const col = db.collection("some-collection");
const trx = db.beginTransaction(col);
await trx.step(() => col.save({ hello: "world" }));
const result = await trx.commit();
// result indicates the updated transaction status +- options: TransactionCommitOptions = {}
exists
get
- get(): Promise<TransactionStatus>
Retrieves general information about the transaction.
+Returns Promise<TransactionStatus>
Example
+const db = new Database();
const col = db.collection("some-collection");
const trx = db.beginTransaction(col);
await trx.step(() => col.save({ hello: "world" }));
const info = await trx.get();
// the transaction exists +
step
- step<T>(callback): Promise<T>
Executes the given function locally as a single step of the transaction.
+Type Parameters
Parameters
- callback: (() => Promise<T>)
Callback function returning a promise.
+Warning: The callback function should wrap a single call of an async +arangojs method (e.g. a method on a
+Collectionobject of a collection +that is involved in the transaction or thedb.querymethod). +If the callback function is async, only the first promise-returning (or +async) method call will be executed as part of the transaction. See the +examples below for how to avoid common mistakes when using this method.Note: Avoid defining the callback as an async function if possible +as arangojs will throw an error if the callback did not return a promise. +Async functions will return an empty promise by default, making it harder +to notice if you forgot to return something from the callback.
+Note: Although almost anything can be wrapped in a callback and passed +to this method, that does not guarantee ArangoDB can actually do it in a +transaction. Refer to the ArangoDB documentation if you are unsure whether +a given operation can be executed as part of a transaction. Generally any +modification or retrieval of data is eligible but modifications of +collections or databases are not.
+
Returns Promise<T>
Example
+const db = new Database();
const vertices = db.collection("vertices");
const edges = db.collection("edges");
const trx = await db.beginTransaction({ write: [vertices, edges] });
// The following code will be part of the transaction
const left = await trx.step(() => vertices.save({ label: "left" }));
const right = await trx.step(() => vertices.save({ label: "right" }));
// Results from preceding actions can be used normally
await trx.step(() => edges.save({
_from: left._id,
_to: right._id,
data: "potato"
}));
// Transaction must be committed for changes to take effected
// Always call either trx.commit or trx.abort to end a transaction
await trx.commit(); +Example
+// BAD! If the callback is an async function it must only use await once!
await trx.step(async () => {
await collection.save(data);
await collection.save(moreData); // WRONG
});
// BAD! Callback function must use only one arangojs call!
await trx.step(() => {
return collection.save(data)
.then(() => collection.save(moreData)); // WRONG
});
// BETTER: Wrap every arangojs method call that should be part of the
// transaction in a separate `trx.step` call
await trx.step(() => collection.save(data));
await trx.step(() => collection.save(moreData)); +Example
+// BAD! If the callback is an async function it must not await before
// calling an arangojs method!
await trx.step(async () => {
await doSomethingElse();
return collection.save(data); // WRONG
});
// BAD! Any arangojs inside the callback must not happen inside a promise
// method!
await trx.step(() => {
return doSomethingElse()
.then(() => collection.save(data)); // WRONG
});
// BETTER: Perform any async logic needed outside the `trx.step` call
await doSomethingElse();
await trx.step(() => collection.save(data));
// OKAY: You can perform async logic in the callback after the arangojs
// method call as long as it does not involve additional arangojs method
// calls, but this makes it easy to make mistakes later
await trx.step(async () => {
await collection.save(data);
await doSomethingDifferent(); // no arangojs method calls allowed
}); +Example
+// BAD! The callback should not use any functions that themselves use any
// arangojs methods!
async function saveSomeData() {
await collection.save(data);
await collection.save(moreData);
}
await trx.step(() => saveSomeData()); // WRONG
// BETTER: Pass the transaction to functions that need to call arangojs
// methods inside a transaction
async function saveSomeData(trx) {
await trx.step(() => collection.save(data));
await trx.step(() => collection.save(moreData));
}
await saveSomeData(); // no `trx.step` call needed +Example
+// BAD! You must wait for the promise to resolve (or await on the
// `trx.step` call) before calling `trx.step` again!
trx.step(() => collection.save(data)); // WRONG
await trx.step(() => collection.save(moreData));
// BAD! The trx.step callback can not make multiple calls to async arangojs
// methods, not even using Promise.all!
await trx.step(() => Promise.all([ // WRONG
collection.save(data),
collection.save(moreData),
]));
// BAD! Multiple `trx.step` calls can not run in parallel!
await Promise.all([ // WRONG
trx.step(() => collection.save(data)),
trx.step(() => collection.save(moreData)),
]));
// BETTER: Always call `trx.step` sequentially, one after the other
await trx.step(() => collection.save(data));
await trx.step(() => collection.save(moreData));
// OKAY: The then callback can be used if async/await is not available
trx.step(() => collection.save(data))
.then(() => trx.step(() => collection.save(moreData))); +Example
+// BAD! The callback will return an empty promise that resolves before
// the inner arangojs method call has even talked to ArangoDB!
await trx.step(async () => {
collection.save(data); // WRONG
});
// BETTER: Use an arrow function so you don't forget to return
await trx.step(() => collection.save(data));
// OKAY: Remember to always return when using a function body
await trx.step(() => {
return collection.save(data); // easy to forget!
});
// OKAY: You do not have to use arrow functions but it helps
await trx.step(function () {
return collection.save(data);
}); +Example
+// BAD! You can not pass promises instead of a callback!
await trx.step(collection.save(data)); // WRONG
// BETTER: Wrap the code in a function and pass the function instead
await trx.step(() => collection.save(data)); +Example
+// WORSE: Calls to non-async arangojs methods don't need to be performed
// as part of a transaction
const collection = await trx.step(() => db.collection("my-documents"));
// BETTER: If an arangojs method is not async and doesn't return promises,
// call it without `trx.step`
const collection = db.collection("my-documents"); +- callback: (() => Promise<T>)
Class View
Represents a View in a database.Database.
+ Index
Accessors
Methods
Accessors
name
- get name(): string
Name of the View.
+Returns string
Methods
create
- create<Options>(options): Promise<Options extends CreateSearchAliasViewOptions
? SearchAliasViewDescription
: ViewDescription> Creates a View with the given
+optionsand the instance's name.See also database.Database#createView.
+Type Parameters
- Options extends CreateViewOptions
Parameters
- options: CreateViewOptions
Returns Promise<Options extends CreateSearchAliasViewOptions
? SearchAliasViewDescription
: ViewDescription>Example
+const db = new Database();
const view = db.view("potatoes");
await view.create();
// the ArangoSearch View "potatoes" now exists +
drop
exists
get
- get(): Promise<ArangoApiResponse<ViewDescription>>
Retrieves general information about the View.
+Returns Promise<ArangoApiResponse<ViewDescription>>
Example
+const db = new Database();
const view = db.view("some-view");
const data = await view.get();
// data contains general information about the View +
properties
- properties(): Promise<ArangoApiResponse<ViewProperties>>
Retrieves the View's properties.
+Returns Promise<ArangoApiResponse<ViewProperties>>
Example
+const db = new Database();
const view = db.view("some-view");
const data = await view.properties();
// data contains the View's properties +
rename
- rename(newName): Promise<ArangoApiResponse<ViewDescription>>
Renames the View and updates the instance's
+nametonewName.Additionally removes the instance from the database.Database's internal +cache.
+Note: Renaming Views may not be supported when ArangoDB is +running in a cluster configuration.
+Parameters
- newName: string
The new name of the View.
+
Returns Promise<ArangoApiResponse<ViewDescription>>
Example
+const db = new Database();
const view1 = db.view("some-view");
await view1.rename("other-view");
const view2 = db.view("some-view");
const view3 = db.view("other-view");
// Note all three View instances are different objects but
// view1 and view3 represent the same ArangoDB view! +- newName: string
replace
- replace
Properties<Properties>(properties?): Promise<Properties extends ArangoSearchViewPropertiesOptions
? ArangoSearchViewProperties
: Properties extends SearchAliasViewPropertiesOptions
? SearchAliasViewProperties
: ViewProperties> Replaces the properties of the View.
+Type Parameters
- Properties extends undefined | ViewPropertiesOptions
Parameters
Optionalproperties: PropertiesNew properties of the View.
+
Returns Promise<Properties extends ArangoSearchViewPropertiesOptions
? ArangoSearchViewProperties
: Properties extends SearchAliasViewPropertiesOptions
? SearchAliasViewProperties
: ViewProperties>Example
+const db = new Database();
const view = db.view("some-view");
const result = await view.replaceProperties({
consolidationIntervalMsec: 234
});
console.log(result.consolidationIntervalMsec); // 234 +
update
- update
Properties<Properties>(properties?): Promise<Properties extends ArangoSearchViewPropertiesOptions
? ArangoSearchViewProperties
: Properties extends SearchAliasViewPatchPropertiesOptions
? SearchAliasViewProperties
: ViewProperties> Updates the properties of the View.
+Type Parameters
- Properties extends undefined | ViewPatchPropertiesOptions
Parameters
Optionalproperties: PropertiesProperties of the View to update.
+
Returns Promise<Properties extends ArangoSearchViewPropertiesOptions
? ArangoSearchViewProperties
: Properties extends SearchAliasViewPatchPropertiesOptions
? SearchAliasViewProperties
: ViewProperties>Example
+const db = new Database();
const view = db.view("some-view");
const result = await view.updateProperties({
consolidationIntervalMsec: 234
});
console.log(result.consolidationIntervalMsec); // 234 +
Function aql
- aql<T>(templateStrings, ...args): AqlQuery<T>
Template string handler (template tag) for AQL queries.
+The
+aqltag can be used to write complex AQL queries as multi-line strings +without having to worry aboutbindVarsand the distinction between +collections and regular parameters.Tagged template strings will return an AqlQuery object with +
+queryandbindVarsattributes reflecting any interpolated values.Any collection.ArangoCollection instance used in a query string will +be recognized as a collection reference and generate an AQL collection bind +parameter instead of a regular AQL value bind parameter.
+Note: you should always use the
+aqltemplate tag when writing +dynamic AQL queries instead of using untagged (normal) template strings. +Untagged template strings will inline any interpolated values and return +a plain string as result. Theaqltemplate tag will only inline references +to the interpolated values and produce an AQL query object containing both +the query and the values. This prevents most injection attacks when using +untrusted values in dynamic queries.Type Parameters
Parameters
- templateStrings: TemplateStringsArray
Rest...args: AqlValue[]
Returns AqlQuery<T>
Example
+// Some user-supplied string that may be malicious
const untrustedValue = req.body.email;
// Without aql tag: BAD! DO NOT DO THIS!
const badQuery = `
FOR user IN users
FILTER user.email == "${untrustedValue}"
RETURN user
`;
// e.g. if untrustedValue is '" || user.admin == true || "':
// Query:
// FOR user IN users
// FILTER user.email == "" || user.admin == true || ""
// RETURN user
// With the aql tag: GOOD! MUCH SAFER!
const betterQuery = aql`
FOR user IN users
FILTER user.email == ${untrustedValue}
RETURN user
`;
// Query:
// FOR user IN users
// FILTER user.email == @value0
// RETURN user
// Bind parameters:
// value0 -> untrustedValue +Example
+const collection = db.collection("some-collection");
const minValue = 23;
const result = await db.query(aql`
FOR d IN ${collection}
FILTER d.num > ${minValue}
RETURN d
`);
// Equivalent raw query object
const result2 = await db.query({
query: `
FOR d IN @@collection
FILTER d.num > @minValue
RETURN d
`,
bindVars: {
"@collection": collection.name,
minValue: minValue
}
}); +Example
+const collection = db.collection("some-collection");
const color = "green";
const filter = aql`FILTER d.color == ${color}'`;
const result = await db.query(aql`
FOR d IN ${collection}
${filter}
RETURN d
`); +
Function isAqlLiteral
- is
Aql Literal(literal): literal is AqlLiteral Indicates whether the given value is an AqlLiteral.
+Parameters
- literal: any
A value that might be an
+AqlLiteral.
Returns literal is AqlLiteral
- literal: any
Function join
- join(values, sep?): AqlQuery
Constructs AqlQuery objects from an array of arbitrary values.
+Note: Nesting
+aqltemplate strings is a much safer alternative +for most use cases. This low-level helper function only exists to +complement theaqltag when constructing complex queries from dynamic +arrays of query fragments.Parameters
- values: AqlValue[]
Array of values to join. These values will behave exactly +like values interpolated in an
+aqltemplate string. - sep: string = " "
Seperator to insert between values. This value will behave +exactly like a value passed to literal, i.e. it will be +inlined as-is, rather than being converted into a bind parameter.
+
Returns AqlQuery
Example
+const users = db.collection("users");
const filters = [];
if (adminsOnly) filters.push(aql`FILTER user.admin`);
if (activeOnly) filters.push(aql`FILTER user.active`);
const result = await db.query(aql`
FOR user IN ${users}
${join(filters)}
RETURN user
`); +Example
+const users = db.collection("users");
const keys = ["jreyes", "ghermann"];
// BAD! NEEDLESSLY COMPLEX!
const docs = keys.map(key => aql`DOCUMENT(${users}, ${key}`));
const result = await db.query(aql`
FOR user IN [
${join(docs, ", ")}
]
RETURN user
`);
// Query:
// FOR user IN [
// DOCUMENT(@@value0, @value1), DOCUMENT(@@value0, @value2)
// ]
// RETURN user
// Bind parameters:
// @value0 -> "users"
// value1 -> "jreyes"
// value2 -> "ghermann"
// GOOD! MUCH SIMPLER!
const result = await db.query(aql`
FOR key IN ${keys}
LET user = DOCUMENT(${users}, key)
RETURN user
`);
// Query:
// FOR user IN @value0
// LET user = DOCUMENT(@@value1, key)
// RETURN user
// Bind parameters:
// value0 -> ["jreyes", "ghermann"]
// @value1 -> "users" +- values: AqlValue[]
Function literal
- literal(value): AqlLiteral
Marks an arbitrary scalar value (i.e. a string, number or boolean) as +safe for being inlined directly into AQL queries when used in an
+aql+template string, rather than being converted into a bind parameter.Note: Nesting
+aqltemplate strings is a much safer alternative for +most use cases. This low-level helper function only exists to help with +rare edge cases where a trusted AQL query fragment must be read from a +string (e.g. when reading query fragments from JSON) and should only be +used as a last resort.Parameters
- value: undefined | null | string | number | boolean | AqlLiteral
Returns AqlLiteral
Example
+// BAD! DO NOT DO THIS!
const sortDirection = literal('ASC');
// GOOD! DO THIS INSTEAD!
const sortDirection = aql`ASC`; +Example
+// BAD! DO NOT DO THIS!
const filterColor = literal('FILTER d.color == "green"');
const result = await db.query(aql`
FOR d IN some-collection
${filterColor}
RETURN d
`);
// GOOD! DO THIS INSTEAD!
const color = "green";
const filterColor = aql`FILTER d.color === ${color}`;
const result = await db.query(aql`
FOR d IN some-collection
${filterColor}
RETURN d
`); +Example
+// WARNING: We explicitly trust the environment variable to be safe!
const filter = literal(process.env.FILTER_STATEMENT);
const users = await db.query(aql`
FOR user IN users
${filter}
RETURN user
`); +
Function collectionToString
- collection
To String(collection): string Coerces the given collection name or ArangoCollection object to +a string representing the collection name.
+Parameters
- collection: string | ArangoCollection
Collection name or ArangoCollection object.
+
Returns string
- collection: string | ArangoCollection
Function isArangoCollection
- is
Arango Collection(collection): collection is ArangoCollection Indicates whether the given value represents an ArangoCollection.
+Parameters
- collection: any
A value that might be a collection.
+
Returns collection is ArangoCollection
- collection: any
Function isArangoError
- is
Arango Error(error): error is ArangoError Indicates whether the given value represents an ArangoError.
+Parameters
- error: any
A value that might be an
+ArangoError.
Returns error is ArangoError
- error: any
Function isSystemError
- is
System Error(err): err is SystemError Indicates whether the given value represents a Node.js
+SystemError.Parameters
- err: any
Returns err is SystemError
Function isArangoGraph
- is
Arango Graph(graph): graph is Graph Indicates whether the given value represents a graph.Graph.
+Parameters
- graph: any
A value that might be a Graph.
+
Returns graph is Graph
- graph: any
Function arangojs
- arangojs(config?): Database
Creates a new
+Databaseinstance with its own connection pool.This is a wrapper function for the database.Database:constructor.
+Parameters
Optionalconfig: ConfigAn object with configuration options.
+
Returns Database
Example
+const db = arangojs({
url: "http://127.0.0.1:8529",
databaseName: "myDatabase",
auth: { username: "admin", password: "hunter2" },
}); +- arangojs(url, name?): Database
Creates a new
+Databaseinstance with its own connection pool.This is a wrapper function for the database.Database:constructor.
+Parameters
- url: string | string[]
Base URL of the ArangoDB server or list of server URLs. +Equivalent to the
+urloption in connection.Config. Optionalname: string
Returns Database
Example
+const db = arangojs("http://127.0.0.1:8529", "myDatabase");
db.useBasicAuth("admin", "hunter2"); +- url: string | string[]
Function isArangoTransaction
- is
Arango Transaction(transaction): transaction is Transaction Indicates whether the given value represents a Transaction.
+Parameters
- transaction: any
A value that might be a transaction.
+
Returns transaction is Transaction
- transaction: any
arangojs - v9.0.0
Class Hierarchy
arangojs - v9.0.0
ArangoDB JavaScript Driver
The official ArangoDB JavaScript client for Node.js and the browser.
+
+
Links
-
+
- + +
- + +
- + +
Install
With npm or yarn
npm install --save arangojs
## - or -
yarn add arangojs
+For browsers
When using modern JavaScript tooling with a bundler and compiler (e.g. Babel),
+arangojs can be installed using npm or yarn like any other dependency.
You can also use jsDelivr CDN during development:
+<script type="importmap">
{
"imports": {
"arangojs": "https://cdn.jsdelivr.net/npm/arangojs@9.0.0-preview.1/esm/index.js?+esm"
}
}
</script>
<script type="module">
import { Database } from "arangojs";
const db = new Database();
// ...
</script>
+Basic usage example
Modern JavaScript/TypeScript with async/await and ES Modules:
+import { Database, aql } from "arangojs";
const db = new Database();
const Pokemons = db.collection("my-pokemons");
async function main() {
try {
const pokemons = await db.query(aql`
FOR pokemon IN ${Pokemons}
FILTER pokemon.type == "fire"
RETURN pokemon
`);
console.log("My pokemans, let me show you them:");
for await (const pokemon of pokemons) {
console.log(pokemon.name);
}
} catch (err) {
console.error(err.message);
}
}
main();
+Using a different database:
+const db = new Database({
url: "http://127.0.0.1:8529",
databaseName: "pancakes",
auth: { username: "root", password: "hunter2" },
});
// The credentials can be swapped at any time
db.useBasicAuth("admin", "maplesyrup");
+Old-school JavaScript with promises and CommonJS:
+var arangojs = require("arangojs");
var Database = arangojs.Database;
var db = new Database();
var pokemons = db.collection("pokemons");
db.query({
query: "FOR p IN @@c FILTER p.type == 'fire' RETURN p",
bindVars: { "@c": "pokemons" },
})
.then(function (cursor) {
console.log("My pokemons, let me show you them:");
return cursor.forEach(function (pokemon) {
console.log(pokemon.name);
});
})
.catch(function (err) {
console.error(err.message);
});
+Note: The examples throughout this documentation use async/await
+and other modern language features like multi-line strings and template tags.
+When developing for an environment without support for these language features,
+substitute promises for await syntax as in the above example.
Compatibility
The arangojs driver is compatible with the latest stable version of ArangoDB +available at the time of the driver release and remains compatible with the +two most recent Node.js LTS versions in accordance with the official +Node.js long-term support schedule. Versions +of ArangoDB that have reached their end of life +by the time of a driver release are explicitly not supported.
+For a list of changes between recent versions of the driver, see the +CHANGELOG.
+Note: arangojs is only intended to be used in Node.js or a browser to access
+ArangoDB from outside the database. If you are looking for the ArangoDB
+JavaScript API for Foxx or for accessing ArangoDB
+from within the arangosh interactive shell, please refer to the documentation
+of the @arangodb module
+and the db object instead.
Error responses
If arangojs encounters an API error, it will throw an ArangoError with
+an errorNum property indicating the ArangoDB error code and the code
+property indicating the HTTP status code from the response body.
For any other non-ArangoDB error responses (4xx/5xx status code), it will throw
+an HttpError error with the status code indicated by the code property.
If the server response did not indicate an error but the response body could
+not be parsed, a regular SyntaxError may be thrown instead.
In all of these cases the server response object will be exposed as the
+response property on the error object.
If the request failed at a network level or the connection was closed without +receiving a response, the underlying system error will be thrown instead.
+Common issues
Missing functions or unexpected server errors
Please make sure you are using the latest version of this driver and that the +version of the arangojs documentation you are reading matches that version.
+Changes in the major version number of arangojs (e.g. 7.x.y -> 8.0.0) indicate +backwards-incompatible changes in the arangojs API that may require changes in +your code when upgrading your version of arangojs.
+Additionally please ensure that your version of Node.js (or browser) and +ArangoDB are supported by the version of arangojs you are trying to use. See +the compatibility section for additional information.
+Note: As of June 2018 ArangoDB 2.8 has reached its End of Life and is no
+longer supported in arangojs 7 and later. If your code needs to work with
+ArangoDB 2.8 you can continue using arangojs 6 and enable ArangoDB 2.8
+compatibility mode by setting the config option arangoVersion: 20800 to
+enable the ArangoDB 2.8 compatibility mode in arangojs 6.
You can install an older version of arangojs using npm or yarn:
# for version 6.x.x
yarn add arangojs@6
# - or -
npm install --save arangojs@6
+No code intelligence when using require instead of import
If you are using require to import the arangojs module in JavaScript, the
+default export might not be recognized as a function by the code intelligence
+of common editors like Visual Studio Code, breaking auto-complete and other
+useful features.
As a workaround, use the arangojs function exported by that module instead
+of calling the module itself:
const arangojs = require("arangojs");
- const db = arangojs({
+ const db = arangojs.arangojs({
url: ARANGODB_SERVER,
});
+Alternatively you can use the Database class directly:
const arangojs = require("arangojs");
+ const Database = arangojs.Database;
- const db = arangojs({
+ const db = new Database({
url: ARANGODB_SERVER,
});
+Or using object destructuring:
+- const arangojs = require("arangojs");
+ const { Database } = require("arangojs");
- const db = arangojs({
+ const db = new Database({
url: ARANGODB_SERVER,
});
+Error stack traces contain no useful information
Due to the async, queue-based behavior of arangojs, the stack traces generated +when an error occur rarely provide enough information to determine the location +in your own code where the request was initiated.
+Using the precaptureStackTraces configuration option, arangojs will attempt
+to always generate stack traces proactively when a request is performed,
+allowing arangojs to provide more meaningful stack traces at the cost of an
+impact to performance even when no error occurs.
const { Database } = require("arangojs");
const db = new Database({
url: ARANGODB_SERVER,
+ precaptureStackTraces: true,
});
+Note that arangojs will attempt to use Error.captureStackTrace if available
+and fall back to generating a stack trace by throwing an error. In environments
+that do not support the stack property on error objects, this option will
+still impact performance but not result in any additional information becoming
+available.
Node.js ReferenceError: window is not defined
If you compile your Node project using a build tool like Webpack, you may need +to tell it to +target the correct environment:
+// webpack.config.js
+ "target": "node",
+To support use in both browser and Node environments arangojs uses the
+package.json browser field,
+to substitute browser-specific implementations for certain modules.
+Build tools like Webpack will respect this field when targetting a browser
+environment and may need to be explicitly told you are targetting Node instead.
Node.js with self-signed HTTPS certificates
If you need to support self-signed HTTPS certificates in Node.js, you may have
+to override the global fetch agent. At the time of this writing, there is no
+official way to do this for the native fetch implementation in Node.js.
However as Node.js uses the undici module for its fetch implementation
+internally, you can override the global agent by adding undici as a
+dependency to your project and using its setGlobalDispatcher as follows:
import { Agent, setGlobalDispatcher } from "undici";
setGlobalDispatcher(
new Agent({
ca: [
fs.readFileSync(".ssl/sub.class1.server.ca.pem"),
fs.readFileSync(".ssl/ca.pem"),
],
})
);
+Although this is strongly discouraged, it's also possible to disable +HTTPS certificate validation entirely, but note this has +extremely dangerous security implications:
+import { Agent, setGlobalDispatcher } from "undici";
setGlobalDispatcher(
new Agent({
rejectUnauthorized: false,
})
);
+When using arangojs in the browser, self-signed HTTPS certificates need to +be trusted by the browser or use a trusted root certificate.
+Streaming transactions leak
When using the transaction.step method it is important to be aware of the
+limitations of what a callback passed to this method is allowed to do.
const collection = db.collection(collectionName);
const trx = db.transaction(transactionId);
// WARNING: This code will not work as intended!
await trx.step(async () => {
await collection.save(doc1);
await collection.save(doc2); // Not part of the transaction!
});
// INSTEAD: Always perform a single operation per step:
await trx.step(() => collection.save(doc1));
await trx.step(() => collection.save(doc2));
+Please refer to the documentation of this method for additional examples.
+Streaming transactions timeout in cluster
Example messages: transaction not found, transaction already expired.
Transactions have +different guarantees +in a cluster.
+When using arangojs in a cluster with load balancing, you may need to adjust
+the value of config.poolSize to accommodate the number of transactions
+you need to be able to run in parallel. The default value is likely to be too
+low for most cluster scenarios involving frequent streaming transactions.
Note: When using a high value for config.poolSize you may have
+to adjust the maximum number of threads in the ArangoDB configuration using
+the server.maximal-threads option
+to support larger numbers of concurrent transactions on the server side.
License
The Apache License, Version 2.0. For more information, see the accompanying +LICENSE file.
+Includes code from x3-linkedlist +used under the MIT license.
+Interface AqlLiteral
An object representing a trusted AQL literal that will be inlined directly +when used in an AQL template or passed to AQL helper functions.
+Arbitrary values can be converted to trusted AQL literals by passing them +to the literal helper function.
+Interface AqlQuery<T>
Generic AQL query object consisting of an AQL query string and its bind +parameters.
+Type Parameters
Properties
Optional [type]
bind
An object mapping AQL bind parameter names to their respective values.
+Names of parameters representing collections are prefixed with an +at-symbol.
+query
An AQL query string.
+Interface ArangoCollection
A marker interface identifying objects that can be used in AQL template +strings to create references to ArangoDB collections.
+See aql!aql.
+Hierarchy (view full)
- ArangoCollection
Implemented by
Index
Properties
Properties
Readonly name
Name of the collection.
+Interface DocumentCollection<EntryResultType, EntryInputType>
Represents an document collection in a database.Database.
+See EdgeCollection for a variant of this interface more suited for +edge collections.
+When using TypeScript, collections can be cast to a specific document data +type to increase type safety.
+Param: T
Type to use for document data. Defaults to any.
Example
interface Person {
name: string;
}
const db = new Database();
const documents = db.collection("persons") as DocumentCollection<Person>;
+name: string;
checksum(options?): Promise<ArangoApiResponse<CollectionMetadata & {
checksum: string;
revision: string;
}>>;
compact(): Promise<ArangoApiResponse<Record<string, never>>>;
count(): Promise<ArangoApiResponse<CollectionMetadata & CollectionProperties & {
count: number;
}>>;
create(options?): Promise<ArangoApiResponse<CollectionMetadata & CollectionProperties>>;
document(selector, options?): Promise<Document<EntryResultType>>;
document(selector, graceful): Promise<Document<EntryResultType>>;
documentExists(selector, options?): Promise<boolean>;
documentId(selector): string;
documents(selectors, options?): Promise<Document<EntryResultType>[]>;
drop(options?): Promise<ArangoApiResponse<Record<string, never>>>;
dropIndex(selector): Promise<ArangoApiResponse<{
id: string;
}>>;
ensureIndex(details): Promise<ArangoApiResponse<GenericIndex & {
cacheEnabled: boolean;
deduplicate: boolean;
estimates: boolean;
fields: string[];
storedValues?: string[];
type: "persistent";
} & {
isNewlyCreated: boolean;
}>>;
ensureIndex(details): Promise<ArangoApiResponse<GenericIndex & {
expireAfter: number;
fields: [string];
selectivityEstimate: number;
type: "ttl";
} & {
isNewlyCreated: boolean;
}>>;
ensureIndex(details): Promise<ArangoApiResponse<GenericIndex & {
fieldValueTypes: "double";
fields: string[];
type: "mdi";
} & {
isNewlyCreated: boolean;
}>>;
ensureIndex(details): Promise<ArangoApiResponse<GenericIndex & {
bestIndexedLevel: number;
fields: [string, string] | [string];
geoJson: boolean;
legacyPolygons: boolean;
maxNumCoverCells: number;
type: "geo";
worstIndexedLevel: number;
} & {
isNewlyCreated: boolean;
}>>;
ensureIndex(details): Promise<ArangoApiResponse<GenericIndex & {
analyzer: string;
cache?: boolean;
cleanupIntervalStep: number;
commitIntervalMsec: number;
consolidationIntervalMsec: number;
consolidationPolicy: Required<TierConsolidationPolicy>;
features: AnalyzerFeature[];
fields: {
analyzer?: string;
cache?: boolean;
features?: AnalyzerFeature[];
includeAllFields?: boolean;
name: string;
nested?: InvertedIndexNestedField[];
searchField?: boolean;
trackListPositions?: boolean;
}[];
includeAllFields: boolean;
optimizeTopK: string[];
parallelism: number;
primaryKeyCache?: boolean;
primarySort: {
cache?: boolean;
compression: Compression;
fields: {
direction: Direction;
field: string;
}[];
};
searchField: boolean;
storedValues: {
cache?: boolean;
compression: Compression;
fields: string[];
}[];
trackListPositions: boolean;
type: "inverted";
writeBufferActive: number;
writeBufferIdle: number;
writeBufferSizeMax: number;
} & {
isNewlyCreated: boolean;
}>>;
ensureIndex(details): Promise<ArangoApiResponse<Index & {
isNewlyCreated: boolean;
}>>;
exists(): Promise<boolean>;
figures(details?): Promise<ArangoApiResponse<CollectionMetadata & CollectionProperties & {
count: number;
figures: Record<string, any>;
}>>;
get(): Promise<ArangoApiResponse<CollectionMetadata>>;
getResponsibleShard(document): Promise<string>;
import(data, options?): Promise<CollectionImportResult>;
import(data, options?): Promise<CollectionImportResult>;
import(data, options?): Promise<CollectionImportResult>;
index(selector): Promise<Index>;
indexes(options?): Promise<Index[]>;
loadIndexes(): Promise<boolean>;
properties(): Promise<ArangoApiResponse<CollectionMetadata & CollectionProperties>>;
properties(properties): Promise<ArangoApiResponse<CollectionMetadata & CollectionProperties>>;
recalculateCount(): Promise<boolean>;
remove(selector, options?): Promise<DocumentMetadata & {
old?: Document<EntryResultType>;
}>;
removeAll(selectors, options?): Promise<(DocumentOperationFailure | DocumentMetadata & {
old?: Document<EntryResultType>;
})[]>;
rename(newName): Promise<ArangoApiResponse<CollectionMetadata>>;
replace(selector, newData, options?): Promise<DocumentMetadata & {
_oldRev?: string;
} & {
new?: Document<EntryResultType>;
old?: Document<EntryResultType>;
}>;
replaceAll(newData, options?): Promise<(DocumentOperationFailure | DocumentMetadata & {
_oldRev?: string;
} & {
new?: Document<EntryResultType>;
old?: Document<EntryResultType>;
})[]>;
revision(): Promise<ArangoApiResponse<CollectionMetadata & CollectionProperties & {
revision: string;
}>>;
save(data, options?): Promise<DocumentMetadata & {
_oldRev?: string;
} & {
new?: Document<EntryResultType>;
old?: Document<EntryResultType>;
}>;
saveAll(data, options?): Promise<(DocumentOperationFailure | DocumentMetadata & {
_oldRev?: string;
} & {
new?: Document<EntryResultType>;
old?: Document<EntryResultType>;
})[]>;
truncate(): Promise<ArangoApiResponse<CollectionMetadata>>;
update(selector, newData, options?): Promise<DocumentMetadata & {
_oldRev?: string;
} & {
new?: Document<EntryResultType>;
old?: Document<EntryResultType>;
}>;
updateAll(newData, options?): Promise<(DocumentOperationFailure | DocumentMetadata & {
_oldRev?: string;
} & {
new?: Document<EntryResultType>;
old?: Document<EntryResultType>;
})[]>;
}
Type Parameters
- EntryResultType extends Record<string, any> = any
- EntryInputType extends Record<string, any> = EntryResultType
Hierarchy (view full)
- ArangoCollection
- DocumentCollection
Index
Properties
Methods
Properties
Readonly name
Name of the collection.
+Methods
checksum
- checksum(options?): Promise<ArangoApiResponse<CollectionMetadata & {
checksum: string;
revision: string;
}>> Retrieves the collection checksum.
+Parameters
Optionaloptions: CollectionChecksumOptionsOptions for retrieving the checksum.
+
Returns Promise<ArangoApiResponse<CollectionMetadata & {
checksum: string;
revision: string;
}>>Example
+const db = new Database();
const collection = db.collection("some-collection");
const data = await collection.checksum();
// data contains the collection's checksum +
compact
- compact(): Promise<ArangoApiResponse<Record<string, never>>>
Triggers compaction for a collection.
+Returns Promise<ArangoApiResponse<Record<string, never>>>
Example
+const db = new Database();
const collection = db.collection("some-collection");
await collection.compact();
// Background compaction is triggered on the collection +
count
- count(): Promise<ArangoApiResponse<CollectionMetadata & CollectionProperties & {
count: number;
}>> Retrieves information about the number of documents in a collection.
+Returns Promise<ArangoApiResponse<CollectionMetadata & CollectionProperties & {
count: number;
}>>Example
+const db = new Database();
const collection = db.collection("some-collection");
const data = await collection.count();
// data contains the collection's count +
create
- create(options?): Promise<ArangoApiResponse<CollectionMetadata & CollectionProperties>>
Creates a collection with the given
+optionsand the instance's name.See also database.Database#createCollection and +database.Database#createEdgeCollection.
+Note: When called on an EdgeCollection instance in TypeScript, +the
+typeoption must still be set to the correct CollectionType. +Otherwise this will result in the collection being created with the +default type (i.e. as a document collection).Parameters
Optionaloptions: CreateCollectionOptions & {
type?: CollectionType;
}Options for creating the collection.
+
Returns Promise<ArangoApiResponse<CollectionMetadata & CollectionProperties>>
Example
+const db = new Database();
const collection = db.collection("potatoes");
await collection.create();
// the document collection "potatoes" now exists +Example
+const db = new Database();
const collection = db.collection("friends");
await collection.create({ type: CollectionType.EDGE_COLLECTION });
// the edge collection "friends" now exists +Example
+interface Friend {
startDate: number;
endDate?: number;
}
const db = new Database();
const collection = db.collection("friends") as EdgeCollection<Friend>;
// even in TypeScript you still need to indicate the collection type
// if you want to create an edge collection
await collection.create({ type: CollectionType.EDGE_COLLECTION });
// the edge collection "friends" now exists +
document
- document(selector, options?): Promise<Document<EntryResultType>>
Retrieves the document matching the given key or id.
+Throws an exception when passed a document or
+_idfrom a different +collection.Parameters
- selector: DocumentSelector
Document
+_key,_idor object with either of those +properties (e.g. a document from this collection). Optionaloptions: CollectionReadOptionsOptions for retrieving the document.
+
Returns Promise<Document<EntryResultType>>
Example
+const db = new Database();
const collection = db.collection("some-collection");
try {
const document = await collection.document("abc123");
console.log(document);
} catch (e: any) {
console.error("Could not find document");
} +Example
+const db = new Database();
const collection = db.collection("some-collection");
const document = await collection.document("abc123", { graceful: true });
if (document) {
console.log(document);
} else {
console.error("Could not find document");
} +- selector: DocumentSelector
- document(selector, graceful): Promise<Document<EntryResultType>>
Retrieves the document matching the given key or id.
+Throws an exception when passed a document or
+_idfrom a different +collection.Parameters
- selector: DocumentSelector
Document
+_key,_idor object with either of those +properties (e.g. a document from this collection). - graceful: boolean
If set to
+true,nullis returned instead of an +exception being thrown if the document does not exist.
Returns Promise<Document<EntryResultType>>
Example
+const db = new Database();
const collection = db.collection("some-collection");
try {
const document = await collection.document("abc123", false);
console.log(document);
} catch (e: any) {
console.error("Could not find document");
} +Example
+const db = new Database();
const collection = db.collection("some-collection");
const document = await collection.document("abc123", true);
if (document) {
console.log(document);
} else {
console.error("Could not find document");
} +- selector: DocumentSelector
document
- document
Exists(selector, options?): Promise<boolean> Checks whether a document matching the given key or id exists in this +collection.
+Throws an exception when passed a document or
+_idfrom a different +collection.Parameters
- selector: DocumentSelector
Document
+_key,_idor object with either of those +properties (e.g. a document from this collection). Optionaloptions: DocumentExistsOptions
Returns Promise<boolean>
Example
+const db = new Database();
const collection = db.collection("some-collection");
const exists = await collection.documentExists("abc123");
if (!exists) {
console.log("Document does not exist");
} +- selector: DocumentSelector
document
- document
Id(selector): string Derives a document
+_idfrom the given selector for this collection.Throws an exception when passed a document or
+_idfrom a different +collection.Parameters
- selector: DocumentSelector
Document
+_key,_idor object with either of those +properties (e.g. a document from this collection).
Returns string
Example
+const db = new Database();
const collection = db.collection("some-collection");
const meta = await collection.save({ foo: "bar" }, { returnNew: true });
const doc = meta.new;
console.log(collection.documentId(meta)); // via meta._id
console.log(collection.documentId(doc)); // via doc._id
console.log(collection.documentId(meta._key)); // also works +Example
+const db = new Database();
const collection1 = db.collection("some-collection");
const collection2 = db.collection("other-collection");
const meta = await collection1.save({ foo: "bar" });
// Mixing collections is usually a mistake
console.log(collection1.documentId(meta)); // ok: same collection
console.log(collection2.documentId(meta)); // throws: wrong collection
console.log(collection2.documentId(meta._id)); // also throws
console.log(collection2.documentId(meta._key)); // ok but wrong collection +- selector: DocumentSelector
documents
- documents(selectors, options?): Promise<Document<EntryResultType>[]>
Retrieves the documents matching the given key or id values.
+Throws an exception when passed a document or
+_idfrom a different +collection, or if the document does not exist.Parameters
- selectors: (string | ObjectWithKey)[]
Array of document
+_key,_idor objects with either +of those properties (e.g. a document from this collection). Optionaloptions: CollectionBatchReadOptionsOptions for retrieving the documents.
+
Returns Promise<Document<EntryResultType>[]>
Example
+const db = new Database();
const collection = db.collection("some-collection");
try {
const documents = await collection.documents(["abc123", "xyz456"]);
console.log(documents);
} catch (e: any) {
console.error("Could not find document");
} +- selectors: (string | ObjectWithKey)[]
drop
- drop(options?): Promise<ArangoApiResponse<Record<string, never>>>
Deletes the collection from the database.
+Parameters
Optionaloptions: CollectionDropOptionsOptions for dropping the collection.
+
Returns Promise<ArangoApiResponse<Record<string, never>>>
Example
+const db = new Database();
const collection = db.collection("some-collection");
await collection.drop();
// The collection "some-collection" is now an ex-collection +
drop
- drop
Index(selector): Promise<ArangoApiResponse<{
id: string;
}>> Deletes the index with the given name or
+idfrom the database.Parameters
- selector: IndexSelector
Index name, id or object with either property.
+
Returns Promise<ArangoApiResponse<{
id: string;
}>>Example
+const db = new Database();
const collection = db.collection("some-collection");
await collection.dropIndex("some-index");
// The index "some-index" no longer exists +- selector: IndexSelector
ensure
- ensure
Index(details): Promise<ArangoApiResponse<GenericIndex & {
cacheEnabled: boolean;
deduplicate: boolean;
estimates: boolean;
fields: string[];
storedValues?: string[];
type: "persistent";
} & {
isNewlyCreated: boolean;
}>> Creates a persistent index on the collection if it does not already exist.
+Parameters
- details: EnsurePersistentIndexOptions
Options for creating the persistent index.
+
Returns Promise<ArangoApiResponse<GenericIndex & {
cacheEnabled: boolean;
deduplicate: boolean;
estimates: boolean;
fields: string[];
storedValues?: string[];
type: "persistent";
} & {
isNewlyCreated: boolean;
}>>Example
+const db = new Database();
const collection = db.collection("some-collection");
// Create a unique index for looking up documents by username
await collection.ensureIndex({
type: "persistent",
fields: ["username"],
name: "unique-usernames",
unique: true
}); +- details: EnsurePersistentIndexOptions
- ensure
Index(details): Promise<ArangoApiResponse<GenericIndex & {
expireAfter: number;
fields: [string];
selectivityEstimate: number;
type: "ttl";
} & {
isNewlyCreated: boolean;
}>> Creates a TTL index on the collection if it does not already exist.
+Parameters
- details: EnsureTtlIndexOptions
Options for creating the TTL index.
+
Returns Promise<ArangoApiResponse<GenericIndex & {
expireAfter: number;
fields: [string];
selectivityEstimate: number;
type: "ttl";
} & {
isNewlyCreated: boolean;
}>>Example
+const db = new Database();
const collection = db.collection("some-collection");
// Expire documents with "createdAt" timestamp one day after creation
await collection.ensureIndex({
type: "ttl",
fields: ["createdAt"],
expireAfter: 60 * 60 * 24 // 24 hours
}); +Example
+const db = new Database();
const collection = db.collection("some-collection");
// Expire documents with "expiresAt" timestamp according to their value
await collection.ensureIndex({
type: "ttl",
fields: ["expiresAt"],
expireAfter: 0 // when attribute value is exceeded
}); +- details: EnsureTtlIndexOptions
- ensure
Index(details): Promise<ArangoApiResponse<GenericIndex & {
fieldValueTypes: "double";
fields: string[];
type: "mdi";
} & {
isNewlyCreated: boolean;
}>> Creates a multi-dimensional index on the collection if it does not already exist.
+Parameters
- details: EnsureMdiIndexOptions
Options for creating the multi-dimensional index.
+
Returns Promise<ArangoApiResponse<GenericIndex & {
fieldValueTypes: "double";
fields: string[];
type: "mdi";
} & {
isNewlyCreated: boolean;
}>>Example
+const db = new Database();
const collection = db.collection("some-points");
// Create a multi-dimensional index for the attributes x, y and z
await collection.ensureIndex({
type: "mdi",
fields: ["x", "y", "z"],
fieldValueTypes: "double"
}); +
++- details: EnsureMdiIndexOptions
- ensure
Index(details): Promise<ArangoApiResponse<GenericIndex & {
bestIndexedLevel: number;
fields: [string, string] | [string];
geoJson: boolean;
legacyPolygons: boolean;
maxNumCoverCells: number;
type: "geo";
worstIndexedLevel: number;
} & {
isNewlyCreated: boolean;
}>> Creates a geo index on the collection if it does not already exist.
+Parameters
- details: EnsureGeoIndexOptions
Options for creating the geo index.
+
Returns Promise<ArangoApiResponse<GenericIndex & {
bestIndexedLevel: number;
fields: [string, string] | [string];
geoJson: boolean;
legacyPolygons: boolean;
maxNumCoverCells: number;
type: "geo";
worstIndexedLevel: number;
} & {
isNewlyCreated: boolean;
}>>Example
+const db = new Database();
const collection = db.collection("some-collection");
// Create an index for GeoJSON data
await collection.ensureIndex({
type: "geo",
fields: ["lngLat"],
geoJson: true
}); +- details: EnsureGeoIndexOptions
- ensure
Index(details): Promise<ArangoApiResponse<GenericIndex & {
analyzer: string;
cache?: boolean;
cleanupIntervalStep: number;
commitIntervalMsec: number;
consolidationIntervalMsec: number;
consolidationPolicy: Required<TierConsolidationPolicy>;
features: AnalyzerFeature[];
fields: {
analyzer?: string;
cache?: boolean;
features?: AnalyzerFeature[];
includeAllFields?: boolean;
name: string;
nested?: InvertedIndexNestedField[];
searchField?: boolean;
trackListPositions?: boolean;
}[];
includeAllFields: boolean;
optimizeTopK: string[];
parallelism: number;
primaryKeyCache?: boolean;
primarySort: {
cache?: boolean;
compression: Compression;
fields: {
direction: Direction;
field: string;
}[];
};
searchField: boolean;
storedValues: {
cache?: boolean;
compression: Compression;
fields: string[];
}[];
trackListPositions: boolean;
type: "inverted";
writeBufferActive: number;
writeBufferIdle: number;
writeBufferSizeMax: number;
} & {
isNewlyCreated: boolean;
}>> Creates a inverted index on the collection if it does not already exist.
+Parameters
- details: EnsureInvertedIndexOptions
Options for creating the inverted index.
+
Returns Promise<ArangoApiResponse<GenericIndex & {
analyzer: string;
cache?: boolean;
cleanupIntervalStep: number;
commitIntervalMsec: number;
consolidationIntervalMsec: number;
consolidationPolicy: Required<TierConsolidationPolicy>;
features: AnalyzerFeature[];
fields: {
analyzer?: string;
cache?: boolean;
features?: AnalyzerFeature[];
includeAllFields?: boolean;
name: string;
nested?: InvertedIndexNestedField[];
searchField?: boolean;
trackListPositions?: boolean;
}[];
includeAllFields: boolean;
optimizeTopK: string[];
parallelism: number;
primaryKeyCache?: boolean;
primarySort: {
cache?: boolean;
compression: Compression;
fields: {
direction: Direction;
field: string;
}[];
};
searchField: boolean;
storedValues: {
cache?: boolean;
compression: Compression;
fields: string[];
}[];
trackListPositions: boolean;
type: "inverted";
writeBufferActive: number;
writeBufferIdle: number;
writeBufferSizeMax: number;
} & {
isNewlyCreated: boolean;
}>>Example
+const db = new Database();
const collection = db.collection("some-collection");
// Create an inverted index
await collection.ensureIndex({
type: "inverted",
fields: ["a", { name: "b", analyzer: "text_en" }]
}); +- details: EnsureInvertedIndexOptions
- ensure
Index(details): Promise<ArangoApiResponse<Index & {
isNewlyCreated: boolean;
}>> Creates an index on the collection if it does not already exist.
+Parameters
- details: EnsureIndexOptions
Options for creating the index.
+
Returns Promise<ArangoApiResponse<Index & {
isNewlyCreated: boolean;
}>>Example
+const db = new Database();
const collection = db.collection("some-collection");
// Create a unique index for looking up documents by username
await collection.ensureIndex({
type: "persistent",
fields: ["username"],
name: "unique-usernames",
unique: true
}); +- details: EnsureIndexOptions
exists
figures
- figures(details?): Promise<ArangoApiResponse<CollectionMetadata & CollectionProperties & {
count: number;
figures: Record<string, any>;
}>> Retrieves statistics for a collection.
+Parameters
Optionaldetails: booleanwhether to return extended storage engine-specific details +to the figures, which may cause additional load and impact performance
+
Returns Promise<ArangoApiResponse<CollectionMetadata & CollectionProperties & {
count: number;
figures: Record<string, any>;
}>>Example
+const db = new Database();
const collection = db.collection("some-collection");
const data = await collection.figures();
// data contains the collection's figures +
get
- get(): Promise<ArangoApiResponse<CollectionMetadata>>
Retrieves general information about the collection.
+Returns Promise<ArangoApiResponse<CollectionMetadata>>
Example
+const db = new Database();
const collection = db.collection("some-collection");
const data = await collection.get();
// data contains general information about the collection +
get
- get
Responsible Shard(document): Promise<string> Retrieves the
+shardIdof the shard responsible for the given document.Parameters
- document: Partial<Document<EntryResultType>>
Document in the collection to look up the
+shardIdof.
Returns Promise<string>
Example
+const db = new Database();
const collection = db.collection("some-collection");
const responsibleShard = await collection.getResponsibleShard(); +- document: Partial<Document<EntryResultType>>
import
- import(data, options?): Promise<CollectionImportResult>
Bulk imports the given
+datainto the collection.Parameters
- data: DocumentData<EntryInputType>[]
The data to import, as an array of document data.
+ Optionaloptions: CollectionImportOptionsOptions for importing the data.
+
Returns Promise<CollectionImportResult>
Example
+const db = new Database();
const collection = db.collection("some-collection");
await collection.import(
[
{ _key: "jcd", password: "bionicman" },
{ _key: "jreyes", password: "amigo" },
{ _key: "ghermann", password: "zeitgeist" }
]
); +- data: DocumentData<EntryInputType>[]
- import(data, options?): Promise<CollectionImportResult>
Bulk imports the given
+datainto the collection.Parameters
- data: any[][]
The data to import, as an array containing a single array of +attribute names followed by one or more arrays of attribute values for +each document.
+ Optionaloptions: CollectionImportOptionsOptions for importing the data.
+
Returns Promise<CollectionImportResult>
Example
+const db = new Database();
const collection = db.collection("some-collection");
await collection.import(
[
[ "_key", "password" ],
[ "jcd", "bionicman" ],
[ "jreyes", "amigo" ],
[ "ghermann", "zeitgeist" ]
]
); +- data: any[][]
- import(data, options?): Promise<CollectionImportResult>
Bulk imports the given
+datainto the collection.If
+typeis omitted,datamust contain one JSON array per line with +the first array providing the attribute names and all other arrays +providing attribute values for each document.If
+typeis set to"documents",datamust contain one JSON document +per line.If
+typeis set to"list",datamust contain a JSON array of +documents.If
+typeis set to"auto",datacan be in either of the formats +supported by"documents"or"list".Parameters
- data: string | Buffer | Blob
The data to import as a Buffer (Node), Blob (browser) or +string.
+ Optionaloptions: CollectionImportOptions & {
type?: "documents" | "list" | "auto";
}Options for importing the data.
+
Returns Promise<CollectionImportResult>
Example
+const db = new Database();
const collection = db.collection("some-collection");
await collection.import(
'{"_key":"jcd","password":"bionicman"}\r\n' +
'{"_key":"jreyes","password":"amigo"}\r\n' +
'{"_key":"ghermann","password":"zeitgeist"}\r\n',
{ type: "documents" } // or "auto"
); +Example
+const db = new Database();
const collection = db.collection("some-collection");
await collection.import(
'[{"_key":"jcd","password":"bionicman"},' +
'{"_key":"jreyes","password":"amigo"},' +
'{"_key":"ghermann","password":"zeitgeist"}]',
{ type: "list" } // or "auto"
); +Example
+const db = new Database();
const collection = db.collection("some-collection");
await collection.import(
'["_key","password"]\r\n' +
'["jcd","bionicman"]\r\n' +
'["jreyes","amigo"]\r\n' +
'["ghermann","zeitgeist"]\r\n'
); +- data: string | Buffer | Blob
index
- index(selector): Promise<Index>
Returns an index description by name or
+idif it exists.Parameters
- selector: IndexSelector
Index name, id or object with either property.
+
Returns Promise<Index>
Example
+const db = new Database();
const collection = db.collection("some-collection");
const index = await collection.index("some-index"); +- selector: IndexSelector
indexes
- indexes(options?): Promise<Index[]>
Returns a list of all index descriptions for the collection.
+Parameters
Optionaloptions: IndexListOptionsOptions for fetching the index list.
+
Returns Promise<Index[]>
Example
+const db = new Database();
const collection = db.collection("some-collection");
const indexes = await collection.indexes(); +
load
- load
Indexes(): Promise<boolean> Instructs ArangoDB to load as many indexes of the collection into memory +as permitted by the memory limit.
+Returns Promise<boolean>
Example
+const db = new Database();
const collection = db.collection("indexed-collection");
await collection.loadIndexes();
// the indexes are now loaded into memory +
properties
- properties(): Promise<ArangoApiResponse<CollectionMetadata & CollectionProperties>>
Retrieves the collection's properties.
+Returns Promise<ArangoApiResponse<CollectionMetadata & CollectionProperties>>
Example
+const db = new Database();
const collection = db.collection("some-collection");
const data = await collection.properties();
// data contains the collection's properties +- properties(properties): Promise<ArangoApiResponse<CollectionMetadata & CollectionProperties>>
Replaces the properties of the collection.
+Parameters
- properties: CollectionPropertiesOptions
Returns Promise<ArangoApiResponse<CollectionMetadata & CollectionProperties>>
Example
+const db = new Database();
const collection = db.collection("some-collection");
const result = await collection.setProperties({ waitForSync: true });
// the collection will now wait for data being written to disk
// whenever a document is changed +
recalculate
- recalculate
Count(): Promise<boolean> Instructs ArangoDB to recalculate the collection's document count to fix +any inconsistencies.
+Returns Promise<boolean>
Example
+const db = new Database();
const collection = db.collection("inconsistent-collection");
const badData = await collection.count();
// oh no, the collection count looks wrong -- fix it!
await collection.recalculateCount();
const goodData = await collection.count();
// goodData contains the collection's improved count +
remove
- remove(selector, options?): Promise<DocumentMetadata & {
old?: Document<EntryResultType>;
}> Removes an existing document from the collection.
+Throws an exception when passed a document or
+_idfrom a different +collection.Parameters
- selector: DocumentSelector
Document
+_key,_idor object with either of those +properties (e.g. a document from this collection). Optionaloptions: CollectionRemoveOptionsOptions for removing the document.
+
Returns Promise<DocumentMetadata & {
old?: Document<EntryResultType>;
}>Example
+const db = new Database();
const collection = db.collection("some-collection");
await collection.remove("abc123");
// document with key "abc123" deleted +Example
+const db = new Database();
const collection = db.collection("some-collection");
const doc = await collection.document("abc123");
await collection.remove(doc);
// document with key "abc123" deleted +- selector: DocumentSelector
remove
- remove
All(selectors, options?): Promise<(DocumentOperationFailure | DocumentMetadata & {
old?: Document<EntryResultType>;
})[]> Removes existing documents from the collection.
+Throws an exception when passed any document or
+_idfrom a different +collection.Parameters
- selectors: (string | ObjectWithKey)[]
Documents
+_key,_idor objects with either of those +properties (e.g. documents from this collection). Optionaloptions: Omit<CollectionRemoveOptions, "ifMatch">Options for removing the documents.
+
Returns Promise<(DocumentOperationFailure | DocumentMetadata & {
old?: Document<EntryResultType>;
})[]>Example
+const db = new Database();
const collection = db.collection("some-collection");
await collection.removeAll(["abc123", "def456"]);
// document with keys "abc123" and "def456" deleted +- selectors: (string | ObjectWithKey)[]
rename
- rename(newName): Promise<ArangoApiResponse<CollectionMetadata>>
Renames the collection and updates the instance's
+nametonewName.Additionally removes the instance from the database.Database's internal +cache.
+Note: Renaming collections may not be supported when ArangoDB is +running in a cluster configuration.
+Parameters
- newName: string
The new name of the collection.
+
Returns Promise<ArangoApiResponse<CollectionMetadata>>
Example
+const db = new Database();
const collection1 = db.collection("some-collection");
await collection1.rename("other-collection");
const collection2 = db.collection("some-collection");
const collection3 = db.collection("other-collection");
// Note all three collection instances are different objects but
// collection1 and collection3 represent the same ArangoDB collection! +- newName: string
replace
- replace(selector, newData, options?): Promise<DocumentMetadata & {
_oldRev?: string;
} & {
new?: Document<EntryResultType>;
old?: Document<EntryResultType>;
}> Replaces an existing document in the collection.
+Throws an exception when passed a document or
+_idfrom a different +collection.Parameters
- selector: DocumentSelector
Document
+_key,_idor object with either of those +properties (e.g. a document from this collection). - newData: DocumentData<EntryInputType>
The contents of the new document.
+ Optionaloptions: CollectionReplaceOptionsOptions for replacing the document.
+
Returns Promise<DocumentMetadata & {
_oldRev?: string;
} & {
new?: Document<EntryResultType>;
old?: Document<EntryResultType>;
}>Example
+const db = new Database();
const collection = db.collection("some-collection");
await collection.save({ _key: "a", color: "blue", count: 1 });
const result = await collection.replace(
"a",
{ color: "red" },
{ returnNew: true }
);
console.log(result.new.color, result.new.count); // "red" undefined +- selector: DocumentSelector
replace
- replace
All(newData, options?): Promise<(DocumentOperationFailure | DocumentMetadata & {
_oldRev?: string;
} & {
new?: Document<EntryResultType>;
old?: Document<EntryResultType>;
})[]> Replaces existing documents in the collection, identified by the
+_keyor +_idof each document.Parameters
- newData: (EntryInputType & Partial<DocumentMetadata> & (Partial<EdgeMetadata> & ({ _key: string; } | { _id: string; })))[]
The documents to replace.
+ Optionaloptions: Omit<CollectionReplaceOptions, "ifMatch">Options for replacing the documents.
+
Returns Promise<(DocumentOperationFailure | DocumentMetadata & {
_oldRev?: string;
} & {
new?: Document<EntryResultType>;
old?: Document<EntryResultType>;
})[]>Example
+const db = new Database();
const collection = db.collection("some-collection");
await collection.save({ _key: "a", color: "blue", count: 1 });
await collection.save({ _key: "b", color: "green", count: 3 });
const result = await collection.replaceAll(
[
{ _key: "a", color: "red" },
{ _key: "b", color: "yellow", count: 2 }
],
{ returnNew: true }
);
console.log(result[0].new.color, result[0].new.count); // "red" undefined
console.log(result[1].new.color, result[1].new.count); // "yellow" 2 +- newData: (EntryInputType & Partial<DocumentMetadata> & (Partial<EdgeMetadata> & ({ _key: string; } | { _id: string; })))[]
revision
- revision(): Promise<ArangoApiResponse<CollectionMetadata & CollectionProperties & {
revision: string;
}>> Retrieves the collection revision ID.
+Returns Promise<ArangoApiResponse<CollectionMetadata & CollectionProperties & {
revision: string;
}>>Example
+const db = new Database();
const collection = db.collection("some-collection");
const data = await collection.revision();
// data contains the collection's revision +
save
- save(data, options?): Promise<DocumentMetadata & {
_oldRev?: string;
} & {
new?: Document<EntryResultType>;
old?: Document<EntryResultType>;
}> Inserts a new document with the given
+datainto the collection.Parameters
- data: DocumentData<EntryInputType>
The contents of the new document.
+ Optionaloptions: CollectionInsertOptionsOptions for inserting the document.
+
Returns Promise<DocumentMetadata & {
_oldRev?: string;
} & {
new?: Document<EntryResultType>;
old?: Document<EntryResultType>;
}>Example
+const db = new Database();
const collection = db.collection("some-collection");
const result = await collection.save(
{ _key: "a", color: "blue", count: 1 },
{ returnNew: true }
);
console.log(result.new.color, result.new.count); // "blue" 1 +- data: DocumentData<EntryInputType>
save
- save
All(data, options?): Promise<(DocumentOperationFailure | DocumentMetadata & {
_oldRev?: string;
} & {
new?: Document<EntryResultType>;
old?: Document<EntryResultType>;
})[]> Inserts new documents with the given
+datainto the collection.Parameters
- data: DocumentData<EntryInputType>[]
The contents of the new documents.
+ Optionaloptions: CollectionInsertOptionsOptions for inserting the documents.
+
Returns Promise<(DocumentOperationFailure | DocumentMetadata & {
_oldRev?: string;
} & {
new?: Document<EntryResultType>;
old?: Document<EntryResultType>;
})[]>Example
+const db = new Database();
const collection = db.collection("some-collection");
const result = await collection.saveAll(
[
{ _key: "a", color: "blue", count: 1 },
{ _key: "b", color: "red", count: 2 },
],
{ returnNew: true }
);
console.log(result[0].new.color, result[0].new.count); // "blue" 1
console.log(result[1].new.color, result[1].new.count); // "red" 2 +- data: DocumentData<EntryInputType>[]
truncate
- truncate(): Promise<ArangoApiResponse<CollectionMetadata>>
Deletes all documents in the collection.
+Returns Promise<ArangoApiResponse<CollectionMetadata>>
Example
+const db = new Database();
const collection = db.collection("some-collection");
await collection.truncate();
// millions of documents cry out in terror and are suddenly silenced,
// the collection "some-collection" is now empty +
update
- update(selector, newData, options?): Promise<DocumentMetadata & {
_oldRev?: string;
} & {
new?: Document<EntryResultType>;
old?: Document<EntryResultType>;
}> Updates an existing document in the collection.
+Throws an exception when passed a document or
+_idfrom a different +collection.Parameters
- selector: DocumentSelector
Document
+_key,_idor object with either of those +properties (e.g. a document from this collection). - newData: Patch<DocumentData<EntryInputType>>
The data for updating the document.
+ Optionaloptions: CollectionUpdateOptionsOptions for updating the document.
+
Returns Promise<DocumentMetadata & {
_oldRev?: string;
} & {
new?: Document<EntryResultType>;
old?: Document<EntryResultType>;
}>Example
+const db = new Database();
const collection = db.collection("some-collection");
await collection.save({ _key: "a", color: "blue", count: 1 });
const result = await collection.update(
"a",
{ count: 2 },
{ returnNew: true }
);
console.log(result.new.color, result.new.count); // "blue" 2 +- selector: DocumentSelector
update
- update
All(newData, options?): Promise<(DocumentOperationFailure | DocumentMetadata & {
_oldRev?: string;
} & {
new?: Document<EntryResultType>;
old?: Document<EntryResultType>;
})[]> Updates existing documents in the collection, identified by the
+_keyor +_idof each document.Parameters
- newData: (Patch<DocumentData<EntryInputType>> & ({
_key: string;
} | {
_id: string;
}))[]The data for updating the documents.
+ Optionaloptions: Omit<CollectionUpdateOptions, "ifMatch">Options for updating the documents.
+
Returns Promise<(DocumentOperationFailure | DocumentMetadata & {
_oldRev?: string;
} & {
new?: Document<EntryResultType>;
old?: Document<EntryResultType>;
})[]>Example
+const db = new Database();
const collection = db.collection("some-collection");
await collection.save({ _key: "a", color: "blue", count: 1 });
await collection.save({ _key: "b", color: "green", count: 3 });
const result = await collection.updateAll(
[
{ _key: "a", count: 2 },
{ _key: "b", count: 4 }
],
{ returnNew: true }
);
console.log(result[0].new.color, result[0].new.count); // "blue" 2
console.log(result[1].new.color, result[1].new.count); // "green" 4 +- newData: (Patch<DocumentData<EntryInputType>> & ({
Interface EdgeCollection<EntryResultType, EntryInputType>
Represents an edge collection in a database.Database.
+See DocumentCollection for a more generic variant of this interface +more suited for regular document collections.
+See also graph.GraphEdgeCollection for the type representing an edge +collection in a graph.Graph.
+When using TypeScript, collections can be cast to a specific edge document +data type to increase type safety.
+Param: T
Type to use for edge document data. Defaults to any.
Example
interface Friend {
startDate: number;
endDate?: number;
}
const db = new Database();
const edges = db.collection("friends") as EdgeCollection<Friend>;
+name: string;
checksum(options?): Promise<ArangoApiResponse<CollectionMetadata & {
checksum: string;
revision: string;
}>>;
compact(): Promise<ArangoApiResponse<Record<string, never>>>;
count(): Promise<ArangoApiResponse<CollectionMetadata & CollectionProperties & {
count: number;
}>>;
create(options?): Promise<ArangoApiResponse<CollectionMetadata & CollectionProperties>>;
document(selector, options?): Promise<Edge<EntryResultType>>;
document(selector, graceful): Promise<Edge<EntryResultType>>;
documentExists(selector, options?): Promise<boolean>;
documentId(selector): string;
documents(selectors, options?): Promise<Edge<EntryResultType>[]>;
drop(options?): Promise<ArangoApiResponse<Record<string, never>>>;
dropIndex(selector): Promise<ArangoApiResponse<{
id: string;
}>>;
edges(selector, options?): Promise<ArangoApiResponse<CollectionEdgesResult<EntryResultType>>>;
ensureIndex(details): Promise<ArangoApiResponse<GenericIndex & {
cacheEnabled: boolean;
deduplicate: boolean;
estimates: boolean;
fields: string[];
storedValues?: string[];
type: "persistent";
} & {
isNewlyCreated: boolean;
}>>;
ensureIndex(details): Promise<ArangoApiResponse<GenericIndex & {
expireAfter: number;
fields: [string];
selectivityEstimate: number;
type: "ttl";
} & {
isNewlyCreated: boolean;
}>>;
ensureIndex(details): Promise<ArangoApiResponse<GenericIndex & {
fieldValueTypes: "double";
fields: string[];
type: "mdi";
} & {
isNewlyCreated: boolean;
}>>;
ensureIndex(details): Promise<ArangoApiResponse<GenericIndex & {
bestIndexedLevel: number;
fields: [string, string] | [string];
geoJson: boolean;
legacyPolygons: boolean;
maxNumCoverCells: number;
type: "geo";
worstIndexedLevel: number;
} & {
isNewlyCreated: boolean;
}>>;
ensureIndex(details): Promise<ArangoApiResponse<GenericIndex & {
analyzer: string;
cache?: boolean;
cleanupIntervalStep: number;
commitIntervalMsec: number;
consolidationIntervalMsec: number;
consolidationPolicy: Required<TierConsolidationPolicy>;
features: AnalyzerFeature[];
fields: {
analyzer?: string;
cache?: boolean;
features?: AnalyzerFeature[];
includeAllFields?: boolean;
name: string;
nested?: InvertedIndexNestedField[];
searchField?: boolean;
trackListPositions?: boolean;
}[];
includeAllFields: boolean;
optimizeTopK: string[];
parallelism: number;
primaryKeyCache?: boolean;
primarySort: {
cache?: boolean;
compression: Compression;
fields: {
direction: Direction;
field: string;
}[];
};
searchField: boolean;
storedValues: {
cache?: boolean;
compression: Compression;
fields: string[];
}[];
trackListPositions: boolean;
type: "inverted";
writeBufferActive: number;
writeBufferIdle: number;
writeBufferSizeMax: number;
} & {
isNewlyCreated: boolean;
}>>;
ensureIndex(details): Promise<ArangoApiResponse<Index & {
isNewlyCreated: boolean;
}>>;
exists(): Promise<boolean>;
figures(details?): Promise<ArangoApiResponse<CollectionMetadata & CollectionProperties & {
count: number;
figures: Record<string, any>;
}>>;
get(): Promise<ArangoApiResponse<CollectionMetadata>>;
getResponsibleShard(document): Promise<string>;
import(data, options?): Promise<CollectionImportResult>;
import(data, options?): Promise<CollectionImportResult>;
import(data, options?): Promise<CollectionImportResult>;
inEdges(selector, options?): Promise<ArangoApiResponse<CollectionEdgesResult<EntryResultType>>>;
index(selector): Promise<Index>;
indexes(options?): Promise<Index[]>;
loadIndexes(): Promise<boolean>;
outEdges(selector, options?): Promise<ArangoApiResponse<CollectionEdgesResult<EntryResultType>>>;
properties(): Promise<ArangoApiResponse<CollectionMetadata & CollectionProperties>>;
properties(properties): Promise<ArangoApiResponse<CollectionMetadata & CollectionProperties>>;
recalculateCount(): Promise<boolean>;
remove(selector, options?): Promise<DocumentMetadata & {
old?: Edge<EntryResultType>;
}>;
removeAll(selectors, options?): Promise<(DocumentOperationFailure | DocumentMetadata & {
old?: Edge<EntryResultType>;
})[]>;
rename(newName): Promise<ArangoApiResponse<CollectionMetadata>>;
replace(selector, newData, options?): Promise<DocumentMetadata & {
_oldRev?: string;
} & {
new?: Edge<EntryResultType>;
old?: Edge<EntryResultType>;
}>;
replaceAll(newData, options?): Promise<(DocumentOperationFailure | DocumentMetadata & {
_oldRev?: string;
} & {
new?: Edge<EntryResultType>;
old?: Edge<EntryResultType>;
})[]>;
revision(): Promise<ArangoApiResponse<CollectionMetadata & CollectionProperties & {
revision: string;
}>>;
save(data, options?): Promise<DocumentMetadata & {
_oldRev?: string;
} & {
new?: Edge<EntryResultType>;
old?: Edge<EntryResultType>;
}>;
saveAll(data, options?): Promise<(DocumentOperationFailure | DocumentMetadata & {
_oldRev?: string;
} & {
new?: Edge<EntryResultType>;
old?: Edge<EntryResultType>;
})[]>;
truncate(): Promise<ArangoApiResponse<CollectionMetadata>>;
update(selector, newData, options?): Promise<DocumentMetadata & {
_oldRev?: string;
} & {
new?: Edge<EntryResultType>;
old?: Edge<EntryResultType>;
}>;
updateAll(newData, options?): Promise<(DocumentOperationFailure | DocumentMetadata & {
_oldRev?: string;
} & {
new?: Edge<EntryResultType>;
old?: Edge<EntryResultType>;
})[]>;
}
Type Parameters
- EntryResultType extends Record<string, any> = any
- EntryInputType extends Record<string, any> = EntryResultType
Hierarchy (view full)
- DocumentCollection<EntryResultType, EntryInputType>
- EdgeCollection
Index
Properties
Methods
Properties
Readonly name
Name of the collection.
+Methods
checksum
- checksum(options?): Promise<ArangoApiResponse<CollectionMetadata & {
checksum: string;
revision: string;
}>> Retrieves the collection checksum.
+Parameters
Optionaloptions: CollectionChecksumOptionsOptions for retrieving the checksum.
+
Returns Promise<ArangoApiResponse<CollectionMetadata & {
checksum: string;
revision: string;
}>>Example
+const db = new Database();
const collection = db.collection("some-collection");
const data = await collection.checksum();
// data contains the collection's checksum +
compact
- compact(): Promise<ArangoApiResponse<Record<string, never>>>
Triggers compaction for a collection.
+Returns Promise<ArangoApiResponse<Record<string, never>>>
Example
+const db = new Database();
const collection = db.collection("some-collection");
await collection.compact();
// Background compaction is triggered on the collection +
count
- count(): Promise<ArangoApiResponse<CollectionMetadata & CollectionProperties & {
count: number;
}>> Retrieves information about the number of documents in a collection.
+Returns Promise<ArangoApiResponse<CollectionMetadata & CollectionProperties & {
count: number;
}>>Example
+const db = new Database();
const collection = db.collection("some-collection");
const data = await collection.count();
// data contains the collection's count +
create
- create(options?): Promise<ArangoApiResponse<CollectionMetadata & CollectionProperties>>
Creates a collection with the given
+optionsand the instance's name.See also database.Database#createCollection and +database.Database#createEdgeCollection.
+Note: When called on an EdgeCollection instance in TypeScript, +the
+typeoption must still be set to the correct CollectionType. +Otherwise this will result in the collection being created with the +default type (i.e. as a document collection).Parameters
Optionaloptions: CreateCollectionOptions & {
type?: CollectionType;
}Options for creating the collection.
+
Returns Promise<ArangoApiResponse<CollectionMetadata & CollectionProperties>>
Example
+const db = new Database();
const collection = db.collection("potatoes");
await collection.create();
// the document collection "potatoes" now exists +Example
+const db = new Database();
const collection = db.collection("friends");
await collection.create({ type: CollectionType.EDGE_COLLECTION });
// the edge collection "friends" now exists +Example
+interface Friend {
startDate: number;
endDate?: number;
}
const db = new Database();
const collection = db.collection("friends") as EdgeCollection<Friend>;
// even in TypeScript you still need to indicate the collection type
// if you want to create an edge collection
await collection.create({ type: CollectionType.EDGE_COLLECTION });
// the edge collection "friends" now exists +
document
- document(selector, options?): Promise<Edge<EntryResultType>>
Retrieves the document matching the given key or id.
+Throws an exception when passed a document or
+_idfrom a different +collection, or if the document does not exist.Parameters
- selector: DocumentSelector
Document
+_key,_idor object with either of those +properties (e.g. a document from this collection). Optionaloptions: CollectionReadOptionsOptions for retrieving the document.
+
Returns Promise<Edge<EntryResultType>>
Example
+const db = new Database();
const collection = db.collection("some-collection");
try {
const document = await collection.document("abc123");
console.log(document);
} catch (e: any) {
console.error("Could not find document");
} +Example
+const db = new Database();
const collection = db.collection("some-collection");
const document = await collection.document("abc123", { graceful: true });
if (document) {
console.log(document);
} else {
console.error("Document does not exist");
} +- selector: DocumentSelector
- document(selector, graceful): Promise<Edge<EntryResultType>>
Retrieves the document matching the given key or id.
+Throws an exception when passed a document or
+_idfrom a different +collection, or if the document does not exist.Parameters
- selector: DocumentSelector
Document
+_key,_idor object with either of those +properties (e.g. a document from this collection). - graceful: boolean
If set to
+true,nullis returned instead of an +exception being thrown if the document does not exist.
Returns Promise<Edge<EntryResultType>>
Example
+const db = new Database();
const collection = db.collection("some-collection");
try {
const document = await collection.document("abc123", false);
console.log(document);
} catch (e: any) {
console.error("Could not find document");
} +Example
+const db = new Database();
const collection = db.collection("some-collection");
const document = await collection.document("abc123", true);
if (document) {
console.log(document);
} else {
console.error("Document does not exist");
} +- selector: DocumentSelector
document
- document
Exists(selector, options?): Promise<boolean> Checks whether a document matching the given key or id exists in this +collection.
+Throws an exception when passed a document or
+_idfrom a different +collection.Parameters
- selector: DocumentSelector
Document
+_key,_idor object with either of those +properties (e.g. a document from this collection). Optionaloptions: DocumentExistsOptions
Returns Promise<boolean>
Example
+const db = new Database();
const collection = db.collection("some-collection");
const exists = await collection.documentExists("abc123");
if (!exists) {
console.log("Document does not exist");
} +- selector: DocumentSelector
document
- document
Id(selector): string Derives a document
+_idfrom the given selector for this collection.Throws an exception when passed a document or
+_idfrom a different +collection.Parameters
- selector: DocumentSelector
Document
+_key,_idor object with either of those +properties (e.g. a document from this collection).
Returns string
Example
+const db = new Database();
const collection = db.collection("some-collection");
const meta = await collection.save({ foo: "bar" }, { returnNew: true });
const doc = meta.new;
console.log(collection.documentId(meta)); // via meta._id
console.log(collection.documentId(doc)); // via doc._id
console.log(collection.documentId(meta._key)); // also works +Example
+const db = new Database();
const collection1 = db.collection("some-collection");
const collection2 = db.collection("other-collection");
const meta = await collection1.save({ foo: "bar" });
// Mixing collections is usually a mistake
console.log(collection1.documentId(meta)); // ok: same collection
console.log(collection2.documentId(meta)); // throws: wrong collection
console.log(collection2.documentId(meta._id)); // also throws
console.log(collection2.documentId(meta._key)); // ok but wrong collection +- selector: DocumentSelector
documents
- documents(selectors, options?): Promise<Edge<EntryResultType>[]>
Retrieves the documents matching the given key or id values.
+Throws an exception when passed a document or
+_idfrom a different +collection, or if the document does not exist.Parameters
- selectors: (string | ObjectWithKey)[]
Array of document
+_key,_idor objects with either +of those properties (e.g. a document from this collection). Optionaloptions: CollectionBatchReadOptionsOptions for retrieving the documents.
+
Returns Promise<Edge<EntryResultType>[]>
Example
+const db = new Database();
const collection = db.collection("some-collection");
try {
const documents = await collection.documents(["abc123", "xyz456"]);
console.log(documents);
} catch (e: any) {
console.error("Could not find document");
} +- selectors: (string | ObjectWithKey)[]
drop
- drop(options?): Promise<ArangoApiResponse<Record<string, never>>>
Deletes the collection from the database.
+Parameters
Optionaloptions: CollectionDropOptionsOptions for dropping the collection.
+
Returns Promise<ArangoApiResponse<Record<string, never>>>
Example
+const db = new Database();
const collection = db.collection("some-collection");
await collection.drop();
// The collection "some-collection" is now an ex-collection +
drop
- drop
Index(selector): Promise<ArangoApiResponse<{
id: string;
}>> Deletes the index with the given name or
+idfrom the database.Parameters
- selector: IndexSelector
Index name, id or object with either property.
+
Returns Promise<ArangoApiResponse<{
id: string;
}>>Example
+const db = new Database();
const collection = db.collection("some-collection");
await collection.dropIndex("some-index");
// The index "some-index" no longer exists +- selector: IndexSelector
edges
- edges(selector, options?): Promise<ArangoApiResponse<CollectionEdgesResult<EntryResultType>>>
Retrieves a list of all edges of the document matching the given +
+selector.Throws an exception when passed a document or
+_idfrom a different +collection.Parameters
- selector: DocumentSelector
Document
+_key,_idor object with either of those +properties (e.g. a document from this collection). Optionaloptions: CollectionEdgesOptionsOptions for retrieving the edges.
+
Returns Promise<ArangoApiResponse<CollectionEdgesResult<EntryResultType>>>
Example
+const db = new Database();
const collection = db.collection("edges");
await collection.import([
["_key", "_from", "_to"],
["x", "vertices/a", "vertices/b"],
["y", "vertices/a", "vertices/c"],
["z", "vertices/d", "vertices/a"],
]);
const edges = await collection.edges("vertices/a");
console.log(edges.map((edge) => edge._key)); // ["x", "y", "z"] +- selector: DocumentSelector
ensure
- ensure
Index(details): Promise<ArangoApiResponse<GenericIndex & {
cacheEnabled: boolean;
deduplicate: boolean;
estimates: boolean;
fields: string[];
storedValues?: string[];
type: "persistent";
} & {
isNewlyCreated: boolean;
}>> Creates a persistent index on the collection if it does not already exist.
+Parameters
- details: EnsurePersistentIndexOptions
Options for creating the persistent index.
+
Returns Promise<ArangoApiResponse<GenericIndex & {
cacheEnabled: boolean;
deduplicate: boolean;
estimates: boolean;
fields: string[];
storedValues?: string[];
type: "persistent";
} & {
isNewlyCreated: boolean;
}>>Example
+const db = new Database();
const collection = db.collection("some-collection");
// Create a unique index for looking up documents by username
await collection.ensureIndex({
type: "persistent",
fields: ["username"],
name: "unique-usernames",
unique: true
}); +- details: EnsurePersistentIndexOptions
- ensure
Index(details): Promise<ArangoApiResponse<GenericIndex & {
expireAfter: number;
fields: [string];
selectivityEstimate: number;
type: "ttl";
} & {
isNewlyCreated: boolean;
}>> Creates a TTL index on the collection if it does not already exist.
+Parameters
- details: EnsureTtlIndexOptions
Options for creating the TTL index.
+
Returns Promise<ArangoApiResponse<GenericIndex & {
expireAfter: number;
fields: [string];
selectivityEstimate: number;
type: "ttl";
} & {
isNewlyCreated: boolean;
}>>Example
+const db = new Database();
const collection = db.collection("some-collection");
// Expire documents with "createdAt" timestamp one day after creation
await collection.ensureIndex({
type: "ttl",
fields: ["createdAt"],
expireAfter: 60 * 60 * 24 // 24 hours
}); +Example
+const db = new Database();
const collection = db.collection("some-collection");
// Expire documents with "expiresAt" timestamp according to their value
await collection.ensureIndex({
type: "ttl",
fields: ["expiresAt"],
expireAfter: 0 // when attribute value is exceeded
}); +- details: EnsureTtlIndexOptions
- ensure
Index(details): Promise<ArangoApiResponse<GenericIndex & {
fieldValueTypes: "double";
fields: string[];
type: "mdi";
} & {
isNewlyCreated: boolean;
}>> Creates a multi-dimensional index on the collection if it does not already exist.
+Parameters
- details: EnsureMdiIndexOptions
Options for creating the multi-dimensional index.
+
Returns Promise<ArangoApiResponse<GenericIndex & {
fieldValueTypes: "double";
fields: string[];
type: "mdi";
} & {
isNewlyCreated: boolean;
}>>Example
+const db = new Database();
const collection = db.collection("some-points");
// Create a multi-dimensional index for the attributes x, y and z
await collection.ensureIndex({
type: "mdi",
fields: ["x", "y", "z"],
fieldValueTypes: "double"
}); +
++- details: EnsureMdiIndexOptions
- ensure
Index(details): Promise<ArangoApiResponse<GenericIndex & {
bestIndexedLevel: number;
fields: [string, string] | [string];
geoJson: boolean;
legacyPolygons: boolean;
maxNumCoverCells: number;
type: "geo";
worstIndexedLevel: number;
} & {
isNewlyCreated: boolean;
}>> Creates a geo index on the collection if it does not already exist.
+Parameters
- details: EnsureGeoIndexOptions
Options for creating the geo index.
+
Returns Promise<ArangoApiResponse<GenericIndex & {
bestIndexedLevel: number;
fields: [string, string] | [string];
geoJson: boolean;
legacyPolygons: boolean;
maxNumCoverCells: number;
type: "geo";
worstIndexedLevel: number;
} & {
isNewlyCreated: boolean;
}>>Example
+const db = new Database();
const collection = db.collection("some-collection");
// Create an index for GeoJSON data
await collection.ensureIndex({
type: "geo",
fields: ["lngLat"],
geoJson: true
}); +- details: EnsureGeoIndexOptions
- ensure
Index(details): Promise<ArangoApiResponse<GenericIndex & {
analyzer: string;
cache?: boolean;
cleanupIntervalStep: number;
commitIntervalMsec: number;
consolidationIntervalMsec: number;
consolidationPolicy: Required<TierConsolidationPolicy>;
features: AnalyzerFeature[];
fields: {
analyzer?: string;
cache?: boolean;
features?: AnalyzerFeature[];
includeAllFields?: boolean;
name: string;
nested?: InvertedIndexNestedField[];
searchField?: boolean;
trackListPositions?: boolean;
}[];
includeAllFields: boolean;
optimizeTopK: string[];
parallelism: number;
primaryKeyCache?: boolean;
primarySort: {
cache?: boolean;
compression: Compression;
fields: {
direction: Direction;
field: string;
}[];
};
searchField: boolean;
storedValues: {
cache?: boolean;
compression: Compression;
fields: string[];
}[];
trackListPositions: boolean;
type: "inverted";
writeBufferActive: number;
writeBufferIdle: number;
writeBufferSizeMax: number;
} & {
isNewlyCreated: boolean;
}>> Creates a inverted index on the collection if it does not already exist.
+Parameters
- details: EnsureInvertedIndexOptions
Options for creating the inverted index.
+
Returns Promise<ArangoApiResponse<GenericIndex & {
analyzer: string;
cache?: boolean;
cleanupIntervalStep: number;
commitIntervalMsec: number;
consolidationIntervalMsec: number;
consolidationPolicy: Required<TierConsolidationPolicy>;
features: AnalyzerFeature[];
fields: {
analyzer?: string;
cache?: boolean;
features?: AnalyzerFeature[];
includeAllFields?: boolean;
name: string;
nested?: InvertedIndexNestedField[];
searchField?: boolean;
trackListPositions?: boolean;
}[];
includeAllFields: boolean;
optimizeTopK: string[];
parallelism: number;
primaryKeyCache?: boolean;
primarySort: {
cache?: boolean;
compression: Compression;
fields: {
direction: Direction;
field: string;
}[];
};
searchField: boolean;
storedValues: {
cache?: boolean;
compression: Compression;
fields: string[];
}[];
trackListPositions: boolean;
type: "inverted";
writeBufferActive: number;
writeBufferIdle: number;
writeBufferSizeMax: number;
} & {
isNewlyCreated: boolean;
}>>Example
+const db = new Database();
const collection = db.collection("some-collection");
// Create an inverted index
await collection.ensureIndex({
type: "inverted",
fields: ["a", { name: "b", analyzer: "text_en" }]
}); +- details: EnsureInvertedIndexOptions
- ensure
Index(details): Promise<ArangoApiResponse<Index & {
isNewlyCreated: boolean;
}>> Creates an index on the collection if it does not already exist.
+Parameters
- details: EnsureIndexOptions
Options for creating the index.
+
Returns Promise<ArangoApiResponse<Index & {
isNewlyCreated: boolean;
}>>Example
+const db = new Database();
const collection = db.collection("some-collection");
// Create a unique index for looking up documents by username
await collection.ensureIndex({
type: "persistent",
fields: ["username"],
name: "unique-usernames",
unique: true
}); +- details: EnsureIndexOptions
exists
figures
- figures(details?): Promise<ArangoApiResponse<CollectionMetadata & CollectionProperties & {
count: number;
figures: Record<string, any>;
}>> Retrieves statistics for a collection.
+Parameters
Optionaldetails: booleanwhether to return extended storage engine-specific details +to the figures, which may cause additional load and impact performance
+
Returns Promise<ArangoApiResponse<CollectionMetadata & CollectionProperties & {
count: number;
figures: Record<string, any>;
}>>Example
+const db = new Database();
const collection = db.collection("some-collection");
const data = await collection.figures();
// data contains the collection's figures +
get
- get(): Promise<ArangoApiResponse<CollectionMetadata>>
Retrieves general information about the collection.
+Returns Promise<ArangoApiResponse<CollectionMetadata>>
Example
+const db = new Database();
const collection = db.collection("some-collection");
const data = await collection.get();
// data contains general information about the collection +
get
- get
Responsible Shard(document): Promise<string> Retrieves the
+shardIdof the shard responsible for the given document.Parameters
- document: Partial<Document<EntryResultType>>
Document in the collection to look up the
+shardIdof.
Returns Promise<string>
Example
+const db = new Database();
const collection = db.collection("some-collection");
const responsibleShard = await collection.getResponsibleShard(); +- document: Partial<Document<EntryResultType>>
import
- import(data, options?): Promise<CollectionImportResult>
Bulk imports the given
+datainto the collection.Parameters
- data: EdgeData<EntryInputType>[]
The data to import, as an array of edge data.
+ Optionaloptions: CollectionImportOptionsOptions for importing the data.
+
Returns Promise<CollectionImportResult>
Example
+const db = new Database();
const collection = db.collection("some-collection");
await collection.import(
[
{ _key: "x", _from: "vertices/a", _to: "vertices/b", weight: 1 },
{ _key: "y", _from: "vertices/a", _to: "vertices/c", weight: 2 }
]
); +- data: EdgeData<EntryInputType>[]
- import(data, options?): Promise<CollectionImportResult>
Bulk imports the given
+datainto the collection.Parameters
- data: any[][]
The data to import, as an array containing a single array of +attribute names followed by one or more arrays of attribute values for +each edge document.
+ Optionaloptions: CollectionImportOptionsOptions for importing the data.
+
Returns Promise<CollectionImportResult>
Example
+const db = new Database();
const collection = db.collection("some-collection");
await collection.import(
[
[ "_key", "_from", "_to", "weight" ],
[ "x", "vertices/a", "vertices/b", 1 ],
[ "y", "vertices/a", "vertices/c", 2 ]
]
); +- data: any[][]
- import(data, options?): Promise<CollectionImportResult>
Bulk imports the given
+datainto the collection.If
+typeis omitted,datamust contain one JSON array per line with +the first array providing the attribute names and all other arrays +providing attribute values for each edge document.If
+typeis set to"documents",datamust contain one JSON document +per line.If
+typeis set to"list",datamust contain a JSON array of +edge documents.If
+typeis set to"auto",datacan be in either of the formats +supported by"documents"or"list".Parameters
- data: string | Buffer | Blob
The data to import as a Buffer (Node), Blob (browser) or +string.
+ Optionaloptions: CollectionImportOptions & {
type?: "documents" | "list" | "auto";
}Options for importing the data.
+
Returns Promise<CollectionImportResult>
Example
+const db = new Database();
const collection = db.collection("some-collection");
await collection.import(
'{"_key":"x","_from":"vertices/a","_to":"vertices/b","weight":1}\r\n' +
'{"_key":"y","_from":"vertices/a","_to":"vertices/c","weight":2}\r\n',
{ type: "documents" } // or "auto"
); +Example
+const db = new Database();
const collection = db.collection("some-collection");
await collection.import(
'[{"_key":"x","_from":"vertices/a","_to":"vertices/b","weight":1},' +
'{"_key":"y","_from":"vertices/a","_to":"vertices/c","weight":2}]',
{ type: "list" } // or "auto"
); +Example
+const db = new Database();
const collection = db.collection("some-collection");
await collection.import(
'["_key","_from","_to","weight"]\r\n' +
'["x","vertices/a","vertices/b",1]\r\n' +
'["y","vertices/a","vertices/c",2]\r\n'
); +- data: string | Buffer | Blob
in
- in
Edges(selector, options?): Promise<ArangoApiResponse<CollectionEdgesResult<EntryResultType>>> Retrieves a list of all incoming edges of the document matching the given +
+selector.Throws an exception when passed a document or
+_idfrom a different +collection.Parameters
- selector: DocumentSelector
Document
+_key,_idor object with either of those +properties (e.g. a document from this collection). Optionaloptions: CollectionEdgesOptionsOptions for retrieving the edges.
+
Returns Promise<ArangoApiResponse<CollectionEdgesResult<EntryResultType>>>
Example
+const db = new Database();
const collection = db.collection("edges");
await collection.import([
["_key", "_from", "_to"],
["x", "vertices/a", "vertices/b"],
["y", "vertices/a", "vertices/c"],
["z", "vertices/d", "vertices/a"],
]);
const edges = await collection.inEdges("vertices/a");
console.log(edges.map((edge) => edge._key)); // ["z"] +- selector: DocumentSelector
index
- index(selector): Promise<Index>
Returns an index description by name or
+idif it exists.Parameters
- selector: IndexSelector
Index name, id or object with either property.
+
Returns Promise<Index>
Example
+const db = new Database();
const collection = db.collection("some-collection");
const index = await collection.index("some-index"); +- selector: IndexSelector
indexes
- indexes(options?): Promise<Index[]>
Returns a list of all index descriptions for the collection.
+Parameters
Optionaloptions: IndexListOptionsOptions for fetching the index list.
+
Returns Promise<Index[]>
Example
+const db = new Database();
const collection = db.collection("some-collection");
const indexes = await collection.indexes(); +
load
- load
Indexes(): Promise<boolean> Instructs ArangoDB to load as many indexes of the collection into memory +as permitted by the memory limit.
+Returns Promise<boolean>
Example
+const db = new Database();
const collection = db.collection("indexed-collection");
await collection.loadIndexes();
// the indexes are now loaded into memory +
out
- out
Edges(selector, options?): Promise<ArangoApiResponse<CollectionEdgesResult<EntryResultType>>> Retrieves a list of all outgoing edges of the document matching the given +
+selector.Throws an exception when passed a document or
+_idfrom a different +collection.Parameters
- selector: DocumentSelector
Document
+_key,_idor object with either of those +properties (e.g. a document from this collection). Optionaloptions: CollectionEdgesOptionsOptions for retrieving the edges.
+
Returns Promise<ArangoApiResponse<CollectionEdgesResult<EntryResultType>>>
Example
+const db = new Database();
const collection = db.collection("edges");
await collection.import([
["_key", "_from", "_to"],
["x", "vertices/a", "vertices/b"],
["y", "vertices/a", "vertices/c"],
["z", "vertices/d", "vertices/a"],
]);
const edges = await collection.outEdges("vertices/a");
console.log(edges.map((edge) => edge._key)); // ["x", "y"] +- selector: DocumentSelector
properties
- properties(): Promise<ArangoApiResponse<CollectionMetadata & CollectionProperties>>
Retrieves the collection's properties.
+Returns Promise<ArangoApiResponse<CollectionMetadata & CollectionProperties>>
Example
+const db = new Database();
const collection = db.collection("some-collection");
const data = await collection.properties();
// data contains the collection's properties +- properties(properties): Promise<ArangoApiResponse<CollectionMetadata & CollectionProperties>>
Replaces the properties of the collection.
+Parameters
- properties: CollectionPropertiesOptions
Returns Promise<ArangoApiResponse<CollectionMetadata & CollectionProperties>>
Example
+const db = new Database();
const collection = db.collection("some-collection");
const result = await collection.setProperties({ waitForSync: true });
// the collection will now wait for data being written to disk
// whenever a document is changed +
recalculate
- recalculate
Count(): Promise<boolean> Instructs ArangoDB to recalculate the collection's document count to fix +any inconsistencies.
+Returns Promise<boolean>
Example
+const db = new Database();
const collection = db.collection("inconsistent-collection");
const badData = await collection.count();
// oh no, the collection count looks wrong -- fix it!
await collection.recalculateCount();
const goodData = await collection.count();
// goodData contains the collection's improved count +
remove
- remove(selector, options?): Promise<DocumentMetadata & {
old?: Edge<EntryResultType>;
}> Removes an existing document from the collection.
+Throws an exception when passed a document or
+_idfrom a different +collection.Parameters
- selector: DocumentSelector
Document
+_key,_idor object with either of those +properties (e.g. a document from this collection). Optionaloptions: CollectionRemoveOptionsOptions for removing the document.
+
Returns Promise<DocumentMetadata & {
old?: Edge<EntryResultType>;
}>Example
+const db = new Database();
const collection = db.collection("friends");
const doc = await collection.document("musadir");
await collection.remove(doc);
// document with key "musadir" deleted +- selector: DocumentSelector
remove
- remove
All(selectors, options?): Promise<(DocumentOperationFailure | DocumentMetadata & {
old?: Edge<EntryResultType>;
})[]> Removes existing documents from the collection.
+Throws an exception when passed any document or
+_idfrom a different +collection.Parameters
- selectors: DocumentSelector[]
Documents
+_key,_idor objects with either of those +properties (e.g. documents from this collection). Optionaloptions: CollectionRemoveOptionsOptions for removing the documents.
+
Returns Promise<(DocumentOperationFailure | DocumentMetadata & {
old?: Edge<EntryResultType>;
})[]>Example
+const db = new Database();
const collection = db.collection("friends");
await collection.removeAll(["musadir", "salman"]);
// document with keys "musadir" and "salman" deleted +- selectors: DocumentSelector[]
rename
- rename(newName): Promise<ArangoApiResponse<CollectionMetadata>>
Renames the collection and updates the instance's
+nametonewName.Additionally removes the instance from the database.Database's internal +cache.
+Note: Renaming collections may not be supported when ArangoDB is +running in a cluster configuration.
+Parameters
- newName: string
The new name of the collection.
+
Returns Promise<ArangoApiResponse<CollectionMetadata>>
Example
+const db = new Database();
const collection1 = db.collection("some-collection");
await collection1.rename("other-collection");
const collection2 = db.collection("some-collection");
const collection3 = db.collection("other-collection");
// Note all three collection instances are different objects but
// collection1 and collection3 represent the same ArangoDB collection! +- newName: string
replace
- replace(selector, newData, options?): Promise<DocumentMetadata & {
_oldRev?: string;
} & {
new?: Edge<EntryResultType>;
old?: Edge<EntryResultType>;
}> Replaces an existing document in the collection.
+Throws an exception when passed a document or
+_idfrom a different +collection.Parameters
- selector: DocumentSelector
Document
+_key,_idor object with either of those +properties (e.g. a document from this collection). - newData: DocumentData<EntryInputType>
The contents of the new document.
+ Optionaloptions: CollectionReplaceOptionsOptions for replacing the document.
+
Returns Promise<DocumentMetadata & {
_oldRev?: string;
} & {
new?: Edge<EntryResultType>;
old?: Edge<EntryResultType>;
}>Example
+const db = new Database();
const collection = db.collection("friends");
await collection.save(
{
_key: "musadir",
_from: "users/rana",
_to: "users/mudasir",
active: true,
best: true
}
);
const result = await collection.replace(
"musadir",
{ active: false },
{ returnNew: true }
);
console.log(result.new.active, result.new.best); // false undefined +- selector: DocumentSelector
replace
- replace
All(newData, options?): Promise<(DocumentOperationFailure | DocumentMetadata & {
_oldRev?: string;
} & {
new?: Edge<EntryResultType>;
old?: Edge<EntryResultType>;
})[]> Replaces existing documents in the collection, identified by the
+_keyor +_idof each document.Parameters
- newData: (EntryInputType & Partial<DocumentMetadata> & (Partial<EdgeMetadata> & ({ _key: string; } | { _id: string; })))[]
The documents to replace.
+ Optionaloptions: CollectionReplaceOptionsOptions for replacing the documents.
+
Returns Promise<(DocumentOperationFailure | DocumentMetadata & {
_oldRev?: string;
} & {
new?: Edge<EntryResultType>;
old?: Edge<EntryResultType>;
})[]>Example
+const db = new Database();
const collection = db.collection("friends");
await collection.save(
{
_key: "musadir",
_from: "users/rana",
_to: "users/mudasir",
active: true,
best: true
}
);
await collection.save(
{
_key: "salman",
_from: "users/rana",
_to: "users/salman",
active: false,
best: false
}
);
const result = await collection.replaceAll(
[
{ _key: "musadir", active: false },
{ _key: "salman", active: true, best: true }
],
{ returnNew: true }
);
console.log(result[0].new.active, result[0].new.best); // false undefined
console.log(result[1].new.active, result[1].new.best); // true true +- newData: (EntryInputType & Partial<DocumentMetadata> & (Partial<EdgeMetadata> & ({ _key: string; } | { _id: string; })))[]
revision
- revision(): Promise<ArangoApiResponse<CollectionMetadata & CollectionProperties & {
revision: string;
}>> Retrieves the collection revision ID.
+Returns Promise<ArangoApiResponse<CollectionMetadata & CollectionProperties & {
revision: string;
}>>Example
+const db = new Database();
const collection = db.collection("some-collection");
const data = await collection.revision();
// data contains the collection's revision +
save
- save(data, options?): Promise<DocumentMetadata & {
_oldRev?: string;
} & {
new?: Edge<EntryResultType>;
old?: Edge<EntryResultType>;
}> Inserts a new document with the given
+datainto the collection.Parameters
- data: EdgeData<EntryInputType>
The contents of the new document.
+ Optionaloptions: CollectionInsertOptionsOptions for inserting the document.
+
Returns Promise<DocumentMetadata & {
_oldRev?: string;
} & {
new?: Edge<EntryResultType>;
old?: Edge<EntryResultType>;
}>Example
+const db = new Database();
const collection = db.collection("friends");
const result = await collection.save(
{ _from: "users/rana", _to: "users/mudasir", active: false },
{ returnNew: true }
); +- data: EdgeData<EntryInputType>
save
- save
All(data, options?): Promise<(DocumentOperationFailure | DocumentMetadata & {
_oldRev?: string;
} & {
new?: Edge<EntryResultType>;
old?: Edge<EntryResultType>;
})[]> Inserts new documents with the given
+datainto the collection.Parameters
- data: EdgeData<EntryInputType>[]
The contents of the new documents.
+ Optionaloptions: CollectionInsertOptionsOptions for inserting the documents.
+
Returns Promise<(DocumentOperationFailure | DocumentMetadata & {
_oldRev?: string;
} & {
new?: Edge<EntryResultType>;
old?: Edge<EntryResultType>;
})[]>Example
+const db = new Database();
const collection = db.collection("friends");
const result = await collection.saveAll(
[
{ _from: "users/rana", _to: "users/mudasir", active: false },
{ _from: "users/rana", _to: "users/salman", active: true }
],
{ returnNew: true }
); +- data: EdgeData<EntryInputType>[]
truncate
- truncate(): Promise<ArangoApiResponse<CollectionMetadata>>
Deletes all documents in the collection.
+Returns Promise<ArangoApiResponse<CollectionMetadata>>
Example
+const db = new Database();
const collection = db.collection("some-collection");
await collection.truncate();
// millions of documents cry out in terror and are suddenly silenced,
// the collection "some-collection" is now empty +
update
- update(selector, newData, options?): Promise<DocumentMetadata & {
_oldRev?: string;
} & {
new?: Edge<EntryResultType>;
old?: Edge<EntryResultType>;
}> Updates an existing document in the collection.
+Throws an exception when passed a document or
+_idfrom a different +collection.Parameters
- selector: DocumentSelector
Document
+_key,_idor object with either of those +properties (e.g. a document from this collection). - newData: Patch<DocumentData<EntryInputType>>
The data for updating the document.
+ Optionaloptions: CollectionUpdateOptionsOptions for updating the document.
+
Returns Promise<DocumentMetadata & {
_oldRev?: string;
} & {
new?: Edge<EntryResultType>;
old?: Edge<EntryResultType>;
}>Example
+const db = new Database();
const collection = db.collection("friends");
await collection.save(
{
_key: "musadir",
_from: "users/rana",
_to: "users/mudasir",
active: true,
best: true
}
);
const result = await collection.update(
"musadir",
{ active: false },
{ returnNew: true }
);
console.log(result.new.active, result.new.best); // false true +- selector: DocumentSelector
update
- update
All(newData, options?): Promise<(DocumentOperationFailure | DocumentMetadata & {
_oldRev?: string;
} & {
new?: Edge<EntryResultType>;
old?: Edge<EntryResultType>;
})[]> Updates existing documents in the collection, identified by the
+_keyor +_idof each document.Parameters
- newData: (Patch<DocumentData<EntryInputType>> & ({
_key: string;
} | {
_id: string;
}))[]The data for updating the documents.
+ Optionaloptions: CollectionUpdateOptionsOptions for updating the documents.
+
+const db = new Database();
const collection = db.collection("friends");
await collection.save(
{
_key: "musadir",
_from: "users/rana",
_to: "users/mudasir",
active: true,
best: true
}
);
await collection.save(
{
_key: "salman",
_from: "users/rana",
_to: "users/salman",
active: false,
best: false
}
);
const result = await collection.updateAll(
[
{ _key: "musadir", active: false },
{ _key: "salman", active: true, best: true }
],
{ returnNew: true }
);
console.log(result[0].new.active, result[0].new.best); // false true
console.log(result[1].new.active, result[1].new.best); // true true +
Returns Promise<(DocumentOperationFailure | DocumentMetadata & {
_oldRev?: string;
} & {
new?: Edge<EntryResultType>;
old?: Edge<EntryResultType>;
})[]>- newData: (Patch<DocumentData<EntryInputType>> & ({
Interface CursorExtras
Additional information about the cursor.
+plan?: Record<string, any>;
profile?: Record<string, number>;
stats?: CursorStats;
warnings: {
code: number;
message: string;
}[];
}
Properties
Optional plan
Query execution plan for the executed query.
+Optional profile
Additional profiling information for the executed query.
+Optional stats
Additional statistics about the query execution.
+warnings
code: number;
message: string;
}[]
Warnings encountered while executing the query.
+Type declaration
code: number
message: string
Interface CursorStats
Additional statics about the query execution of the cursor.
+cacheHits: number;
cacheMisses: number;
cursorsCreated: number;
cursorsRearmed: number;
executionTime: number;
filtered: number;
fullCount?: number;
httpRequests: number;
nodes?: {
calls: number;
filter: number;
id: number;
items: number;
runtime: number;
}[];
peakMemoryUsage: number;
scannedFull: number;
scannedIndex: number;
writesExecuted: number;
writesIgnored: number;
}
Index
Properties
cache
Total number of index entries read from in-memory caches for indexes of +type edge or persistent.
+cache
Total number of cache read attempts for index entries that could not be +served from in-memory caches for indexes of type edge or persistent.
+cursors
Total number of cursor objects created during query execution.
+cursors
Total number of times an existing cursor object was repurposed.
+execution
Execution time of the query in seconds.
+filtered
Total number of documents that were removed after executing a filter condition in a FilterNode.
+Optional full
Total number of documents that matched the search condition if the query’s final top-level LIMIT statement were not present.
+http
Total number of cluster-internal HTTP requests performed.
+Optional nodes
calls: number;
filter: number;
id: number;
items: number;
runtime: number;
}[]
Runtime statistics per query execution node if profile was set to 2 or greater.
Type declaration
calls: number
Number of calls in this node.
+filter: number
id: number
Execution node ID to correlate this node with nodes in the
+extra.plan.items: number
Number of temporary result items returned by this node.
+runtime: number
Execution time of this node in seconds.
+
peak
Maximum memory usage of the query while it was running.
+scanned
Total number of documents iterated over when scanning a collection without an index.
+scanned
Total number of documents iterated over when scanning a collection using an index.
+writes
Total number of data-modification operations successfully executed.
+writes
Total number of data-modification operations that were unsuccessful, but have been ignored because of query option ignoreErrors.
+Interface ArangoSearchViewStoredValueOptions
Options for creating a stored value in an ArangoSearch View.
+cache?: boolean;
compression?: Compression;
fields: string[];
}
Index
Properties
Properties
Optional cache
(Enterprise Edition only.) If set to true, then stored values will
+always be cached in memory.
Default: false
Optional compression
How the attribute values should be compressed.
+Default: "lz4"
fields
Attribute paths for which values should be stored in the view index
+in addition to those used for sorting via primarySort.
Module analyzer
import type { Analyzer } from "arangojs/analyzer.js";
+The "analyzer" module provides analyzer related types and interfaces +for TypeScript.
+Index
Classes
Type Aliases
Functions
Module aql
import { aql } from "arangojs/aql.js";
+The "aql" module provides the aql template string handler and +helper functions, as well as associated types and interfaces for TypeScript.
+The aql function and namespace is also re-exported by the "index" module.
+Index
Interfaces
Type Aliases
Functions
Module collection
import type {
DocumentCollection,
EdgeCollection,
} from "arangojs/collection.js";
+The "collection" module provides collection related types and interfaces +for TypeScript.
+Index
Enumerations
Interfaces
Type Aliases
Functions
Module connection
import type { Config } from "arangojs/connection.js";
+The "connection" module provides connection and configuration related types +for TypeScript.
+Index
Type Aliases
Module cursor
import type { ArrayCursor, BatchedArrayCursor } from "arangojs/cursor.js";
+The "cursor" module provides cursor-related interfaces for TypeScript.
+Index
Classes
Interfaces
Module database
import { Database } from "arangojs/database.js";
+The "database" module provides the Database class and associated +types and interfaces for TypeScript.
+The Database class is also re-exported by the "index" module.
+Index
Enumerations
Classes
Type Aliases
Functions
Module documents
import type { Document, Edge } from "arangojs/documents.js";
+The "documents" module provides document/edge related types for TypeScript.
+Index
Type Aliases
Module error
import type { ArangoError, HttpError } from "arangojs/error.js";
+The "error" module provides types and interfaces for TypeScript related +to arangojs error handling.
+Index
Classes
Interfaces
Functions
Module foxx-manifest
import type { FoxxManifest } from "arangojs/foxx-manifest.js";
+The "foxx-manifest" module provides the Foxx manifest type for TypeScript.
+Generated from JSON Schema
+using json-schema-to-typescript.
Index
Type Aliases
Module graph
import type {
Graph,
GraphVertexCollection,
GraphEdgeCollection,
} from "arangojs/graph.js";
+The "graph" module provides graph related types and interfaces +for TypeScript.
+Index
Classes
Type Aliases
Functions
Module index
import arangojs, { aql, Database } from "arangojs";
+The "index" module is the default entry point when importing the arangojs +module or using the web build in the browser.
+If you are just getting started, you probably want to use the +arangojs function, which is also the default export of this module, +or the database.Database class for which it is a wrapper.
+References
Database
Re-exports Databaseaql
Re-exports aqldefault
Renames and re-exports arangojsModule indexes
import type {
FulltextIndex,
GeoIndex,
MdiIndex,
PersistentIndex,
PrimaryIndex,
TtlIndex,
} from "arangojs/indexes.js";
+The "indexes" module provides index-related types for TypeScript.
+Index
Type Aliases
Module job
Index
Classes
Module route
import type { Route } from "arangojs/route.js";
+The "route" module provides route related types and interfaces for TypeScript.
+Index
Classes
Module transaction
import type { Transaction } from "arangojs/transaction.js";
+The "transaction" module provides transaction related types and interfaces +for TypeScript.
+Index
Classes
Type Aliases
Functions
Module view
import type { ArangoSearchView } from "arangojs/view.js";
+The "view" module provides View related types and interfaces for TypeScript.
+Index
Classes
Interfaces
Type Aliases
Functions
Type alias AnalyzerDescription
An object describing an Analyzer.
+Type alias AnalyzerFeature
Name of a feature enabled for an Analyzer.
+Type alias AqlAnalyzerDescription
properties: {
batchSize: number;
collapsePositions: boolean;
keepNull: boolean;
memoryLimit: number;
queryString: string;
returnType: "string" | "number" | "bool";
};
type: "aql";
}
An object describing an AQL Analyzer
+Type declaration
properties: {
batchSize: number;
collapsePositions: boolean;
keepNull: boolean;
memoryLimit: number;
queryString: string;
returnType: "string" | "number" | "bool";
}batch
Size: number collapse
Positions: boolean keep
Null: boolean memory
Limit: number query
String: string return
Type: "string" | "number" | "bool"
type: "aql"
Type alias ClassificationAnalyzerDescription
properties: {
model_location: string;
threshold: number;
top_k: number;
};
type: "classification";
}
(Enterprise Edition only.) An object describing a Classification Analyzer
+Type declaration
properties: {
model_location: string;
threshold: number;
top_k: number;
}model_
location: string threshold: number
top_
k: number
type: "classification"
Type alias CollationAnalyzerDescription
properties: {
locale: string;
};
type: "collation";
}
An object describing a Collation Analyzer
+Type declaration
properties: {
locale: string;
}locale: string
type: "collation"
Type alias CreateAnalyzerOptions
Analyzer type and its type-specific properties.
+Type alias CreateAqlAnalyzerOptions
features?: AnalyzerFeature[];
properties: {
batchSize?: number;
collapsePositions?: boolean;
keepNull?: boolean;
memoryLimit?: number;
queryString: string;
returnType?: "string" | "number" | "bool";
};
type: "aql";
}
Options for creating an AQL Analyzer
+Type declaration
Optionalfeatures?: AnalyzerFeature[]Features to enable for this Analyzer.
+properties: {
batchSize?: number;
collapsePositions?: boolean;
keepNull?: boolean;
memoryLimit?: number;
queryString: string;
returnType?: "string" | "number" | "bool";
}Additional properties for the Analyzer.
+OptionalbatchSize?: number Number between
+1and1000that determines the batch size for reading +data from the query.Default:
+1OptionalcollapsePositions?: boolean If set to
+true, the position is set to0for all members of the query result array.Default:
+falseOptionalkeepNull?: boolean If set to
+false,nullvalues will be discarded from the View index.Default:
+trueOptionalmemoryLimit?: number Memory limit for query execution in bytes.
+Default:
+1048576(1 MiB)query
String: string AQL query to be executed.
+OptionalreturnType?: "string" | "number" | "bool" Data type of the returned tokens.
+Default:
+"string"
type: "aql"
Type of the Analyzer.
+
Type alias CreateClassificationAnalyzerOptions
features?: AnalyzerFeature[];
properties: {
model_location: string;
threshold?: number;
top_k?: number;
};
type: "classification";
}
(Enterprise Edition only.) Options for creating a Classification Analyzer
+Type declaration
Optionalfeatures?: AnalyzerFeature[]Features to enable for this Analyzer.
+properties: {
model_location: string;
threshold?: number;
top_k?: number;
}Additional properties for the Analyzer.
+model_
location: string On-disk path to the trained fastText supervised model.
+Optionalthreshold?: numberProbability threshold for which a label will be assigned to an input.
+Default:
+0.99Optionaltop_k?: number Number of class labels that will be produced per input.
+Default:
+1
type: "classification"
Type of the Analyzer.
+
Type alias CreateCollationAnalyzerOptions
features?: AnalyzerFeature[];
properties: {
locale: string;
};
type: "collation";
}
Options for creating a Collation Analyzer
+Type declaration
Optionalfeatures?: AnalyzerFeature[]Features to enable for this Analyzer.
+properties: {
locale: string;
}Additional properties for the Analyzer.
+locale: string
Text locale.
+Format:
+language[_COUNTRY][.encoding][@variant]
type: "collation"
Type of the Analyzer.
+
Type alias CreateDelimiterAnalyzerOptions
features?: AnalyzerFeature[];
properties: string | {
delimiter: string;
};
type: "delimiter";
}
Options for creating a Delimiter Analyzer.
+Type declaration
Optionalfeatures?: AnalyzerFeature[]Features to enable for this Analyzer.
+properties: string | {
delimiter: string;
}Additional properties for the Analyzer.
+The value will be used as delimiter to split text into tokens as specified +in RFC 4180, without starting new records on newlines.
+type: "delimiter"
Type of the Analyzer.
+
Type alias CreateGeoJsonAnalyzerOptions
features?: AnalyzerFeature[];
properties: {
options?: {
maxCells?: number;
maxLevel?: number;
minLevel?: number;
};
type?: "shape" | "centroid" | "point";
};
type: "geojson";
}
Options for creating a GeoJSON Analyzer
+Type declaration
Optionalfeatures?: AnalyzerFeature[]Features to enable for this Analyzer.
+properties: {
options?: {
maxCells?: number;
maxLevel?: number;
minLevel?: number;
};
type?: "shape" | "centroid" | "point";
}Additional properties for the Analyzer.
+Optionaloptions?: {
maxCells?: number;
maxLevel?: number;
minLevel?: number;
}Options for fine-tuning geo queries.
+Default:
+{ maxCells: 20, minLevel: 4, maxLevel: 23 }OptionalmaxCells?: number OptionalmaxLevel?: number OptionalminLevel?: number
Optionaltype?: "shape" | "centroid" | "point"If set to
+"centroid", only the centroid of the input geometry will be +computed and indexed.If set to
+"point"only GeoJSON objects of type Point will be indexed and +all other geometry types will be ignored.Default:
+"shape"
type: "geojson"
Type of the Analyzer.
+
Type alias CreateGeoPointAnalyzerOptions
features?: AnalyzerFeature[];
properties: {
latitude?: string[];
longitude?: string[];
options?: {
maxLevel?: number;
minCells?: number;
minLevel?: number;
};
};
type: "geopoint";
}
Options for creating a GeoPoint Analyzer
+Type declaration
Optionalfeatures?: AnalyzerFeature[]Features to enable for this Analyzer.
+properties: {
latitude?: string[];
longitude?: string[];
options?: {
maxLevel?: number;
minCells?: number;
minLevel?: number;
};
}Additional properties for the Analyzer.
+Optionallatitude?: string[]Attribute paths of the latitude value relative to the field for which the +Analyzer is defined in the View.
+Optionallongitude?: string[]Attribute paths of the longitude value relative to the field for which the +Analyzer is defined in the View.
+Optionaloptions?: {
maxLevel?: number;
minCells?: number;
minLevel?: number;
}Options for fine-tuning geo queries.
+Default:
+{ maxCells: 20, minLevel: 4, maxLevel: 23 }OptionalmaxLevel?: number OptionalminCells?: number OptionalminLevel?: number
type: "geopoint"
Type of the Analyzer.
+
Type alias CreateGeoS2AnalyzerOptions
features?: AnalyzerFeature[];
properties: {
format?: "latLngDouble" | "latLngInt" | "s2Point";
options?: {
maxCells?: number;
maxLevel?: number;
minLevel?: number;
};
type?: "shape" | "centroid" | "point";
};
type: "geo_s2";
}
(Enterprise Edition only.) Options for creating a Geo S2 Analyzer
+Type declaration
Optionalfeatures?: AnalyzerFeature[]Features to enable for this Analyzer.
+properties: {
format?: "latLngDouble" | "latLngInt" | "s2Point";
options?: {
maxCells?: number;
maxLevel?: number;
minLevel?: number;
};
type?: "shape" | "centroid" | "point";
}Additional properties for the Analyzer.
+Optionalformat?: "latLngDouble" | "latLngInt" | "s2Point"If set to
+"latLngDouble", each latitude and longitude value is stored +as an 8-byte floating-point value (16 bytes per coordinate pair).If set to
+"latLngInt", each latitude and longitude value is stored as +a 4-byte integer value (8 bytes per coordinate pair).If set to
+"s2Point", each longitude-latitude pair is stored in the +native format of Google S2 (24 bytes per coordinate pair).Default:
+"latLngDouble"Optionaloptions?: {
maxCells?: number;
maxLevel?: number;
minLevel?: number;
}Options for fine-tuning geo queries.
+Default:
+{ maxCells: 20, minLevel: 4, maxLevel: 23 }OptionalmaxCells?: number OptionalmaxLevel?: number OptionalminLevel?: number
Optionaltype?: "shape" | "centroid" | "point"If set to
+"centroid", only the centroid of the input geometry will be +computed and indexed.If set to
+"point"only GeoJSON objects of type Point will be indexed and +all other geometry types will be ignored.Default:
+"shape"
type: "geo_s2"
Type of the Analyzer.
+
Type alias CreateIdentityAnalyzerOptions
features?: AnalyzerFeature[];
properties?: Record<string, never>;
type: "identity";
}
Options for creating an Identity Analyzer.
+Type declaration
Optionalfeatures?: AnalyzerFeature[]Features to enable for this Analyzer.
+Optionalproperties?: Record<string, never>Additional properties for the Analyzer.
+The
+identityAnalyzer does not take additional properties.type: "identity"
Type of the Analyzer.
+
Type alias CreateMinHashAnalyzerOptions
features?: AnalyzerFeature[];
properties: {
analyzer: Omit<CreateAnalyzerOptions, "features">;
numHashes: number;
};
type: "minhash";
}
(Enterprise Edition only.) Options for creating a MinHash Analyzer
+Type declaration
Optionalfeatures?: AnalyzerFeature[]Features to enable for this Analyzer.
+properties: {
analyzer: Omit<CreateAnalyzerOptions, "features">;
numHashes: number;
}Additional properties for the Analyzer.
+analyzer: Omit<CreateAnalyzerOptions, "features">
An Analyzer definition-like object with
+typeandpropertiesattributes.num
Hashes: number Size of the MinHash signature.
+
type: "minhash"
Type of the Analyzer.
+
Type alias CreateMultiDelimiterAnalyzerOptions
features?: AnalyzerFeature[];
properties: {
delimiters: string[];
};
type: "multi_delimiter";
}
Options for creating a Multi-Delimiter Analyzer.
+Type declaration
Optionalfeatures?: AnalyzerFeature[]Features to enable for this Analyzer.
+properties: {
delimiters: string[];
}Additional properties for the Analyzer.
+The value will be used as delimiter to split text into tokens as specified +in RFC 4180, without starting new records on newlines.
+delimiters: string[]
type: "multi_delimiter"
Type of the Analyzer.
+
Type alias CreateNearestNeighborsAnalyzerOptions
features?: AnalyzerFeature[];
properties: {
model_location: string;
top_k?: number;
};
type: "nearest_neighbors";
}
(Enterprise Edition only.) Options for creating a NearestNeighbors Analyzer.
+Type declaration
Optionalfeatures?: AnalyzerFeature[]Features to enable for this Analyzer.
+properties: {
model_location: string;
top_k?: number;
}Additional properties for the Analyzer.
+model_
location: string On-disk path to the trained fastText supervised model.
+Optionaltop_k?: number Number of class labels that will be produced per input.
+Default:
+1
type: "nearest_neighbors"
Type of the Analyzer.
+
Type alias CreateNgramAnalyzerOptions
features?: AnalyzerFeature[];
properties: {
max: number;
min: number;
preserveOriginal: boolean;
};
type: "ngram";
}
Options for creating an Ngram Analyzer.
+Type declaration
Optionalfeatures?: AnalyzerFeature[]Features to enable for this Analyzer.
+properties: {
max: number;
min: number;
preserveOriginal: boolean;
}Additional properties for the Analyzer.
+max: number
Maximum n-gram length.
+min: number
Minimum n-gram length.
+preserve
Original: boolean Output the original value as well.
+
type: "ngram"
Type of the Analyzer.
+
Type alias CreateNormAnalyzerOptions
features?: AnalyzerFeature[];
properties: {
accent?: boolean;
case?: "lower" | "none" | "upper";
locale: string;
};
type: "norm";
}
Options for creating a Norm Analyzer.
+Type declaration
Optionalfeatures?: AnalyzerFeature[]Features to enable for this Analyzer.
+properties: {
accent?: boolean;
case?: "lower" | "none" | "upper";
locale: string;
}Additional properties for the Analyzer.
+Optionalaccent?: booleanPreserve accents in returned words.
+Default:
+falseOptionalcase?: "lower" | "none" | "upper"Case conversion.
+Default:
+"lower"locale: string
Text locale.
+Format:
+language[_COUNTRY][.encoding][@variant]
type: "norm"
Type of the Analyzer.
+
Type alias CreatePipelineAnalyzerOptions
features?: AnalyzerFeature[];
properties: {
pipeline: Omit<CreateAnalyzerOptions, "features">[];
};
type: "pipeline";
}
Options for creating a Pipeline Analyzer
+Type declaration
Optionalfeatures?: AnalyzerFeature[]Features to enable for this Analyzer.
+properties: {
pipeline: Omit<CreateAnalyzerOptions, "features">[];
}Additional properties for the Analyzer.
+pipeline: Omit<CreateAnalyzerOptions, "features">[]
Definitions for Analyzers to chain in this Pipeline Analyzer.
+
type: "pipeline"
Type of the Analyzer.
+
Type alias CreateSegmentationAnalyzerOptions
features?: AnalyzerFeature[];
properties: {
break?: "all" | "alpha" | "graphic";
case?: "lower" | "upper" | "none";
};
type: "segmentation";
}
Options for creating a Segmentation Analyzer
+Type declaration
Optionalfeatures?: AnalyzerFeature[]Features to enable for this Analyzer.
+properties: {
break?: "all" | "alpha" | "graphic";
case?: "lower" | "upper" | "none";
}Additional properties for the Analyzer.
+Optionalbreak?: "all" | "alpha" | "graphic"Which tokens should be returned.
+Default:
+"alpha"Optionalcase?: "lower" | "upper" | "none"What case all returned tokens should be converted to if applicable.
+Default:
+"none"
type: "segmentation"
Type of the Analyzer.
+
Type alias CreateStemAnalyzerOptions
features?: AnalyzerFeature[];
properties: {
locale: string;
};
type: "stem";
}
Options for creating a Stem Analyzer.
+Type declaration
Optionalfeatures?: AnalyzerFeature[]Features to enable for this Analyzer.
+properties: {
locale: string;
}Additional properties for the Analyzer.
+The value defines the text locale.
+Format:
+language[_COUNTRY][.encoding][@variant]locale: string
type: "stem"
Type of the Analyzer.
+
Type alias CreateStopwordsAnalyzerOptions
features?: AnalyzerFeature[];
properties: {
hex?: boolean;
stopwords: string[];
};
type: "stopwords";
}
Options for creating a Stopwords Analyzer
+Type declaration
Optionalfeatures?: AnalyzerFeature[]Features to enable for this Analyzer.
+properties: {
hex?: boolean;
stopwords: string[];
}Additional properties for the Analyzer.
+Optionalhex?: booleanWhether stopword values should be interpreted as hex-encoded strings.
+Default:
+falsestopwords: string[]
Array of strings that describe the tokens to be discarded.
+
type: "stopwords"
Type of the Analyzer.
+
Type alias CreateTextAnalyzerOptions
features?: AnalyzerFeature[];
properties: {
accent?: boolean;
case?: "lower" | "none" | "upper";
edgeNgram?: {
max?: number;
min?: number;
preserveOriginal?: boolean;
};
locale: string;
stemming?: boolean;
stopwords?: string[];
stopwordsPath?: string;
};
type: "text";
}
Options for creating a Text Analyzer.
+Type declaration
Optionalfeatures?: AnalyzerFeature[]Features to enable for this Analyzer.
+properties: {
accent?: boolean;
case?: "lower" | "none" | "upper";
edgeNgram?: {
max?: number;
min?: number;
preserveOriginal?: boolean;
};
locale: string;
stemming?: boolean;
stopwords?: string[];
stopwordsPath?: string;
}Additional properties for the Analyzer.
+Optionalaccent?: booleanPreserve accents in returned words.
+Default:
+falseOptionalcase?: "lower" | "none" | "upper"Case conversion.
+Default:
+"lower"OptionaledgeNgram?: {
max?: number;
min?: number;
preserveOriginal?: boolean;
}If present, then edge n-grams are generated for each token (word).
+Optionalmax?: numberOptionalmin?: numberOptionalpreserveOriginal?: boolean
locale: string
Text locale.
+Format:
+language[_COUNTRY][.encoding][@variant]Optionalstemming?: booleanApply stemming on returned words.
+Default:
+trueOptionalstopwords?: string[]Words to omit from result.
+Defaults to the words loaded from the file at
+stopwordsPath.OptionalstopwordsPath?: string Path with a
+languagesub-directory containing files with words to omit.Defaults to the path specified in the server-side environment variable +
+IRESEARCH_TEXT_STOPWORD_PATHor the current working directory of the +ArangoDB process.
type: "text"
Type of the Analyzer.
+
Type alias CreateWildcardAnalyzerOptions
features?: AnalyzerFeature[];
properties: {
analyzer?: Omit<CreateAnalyzerOptions, "features">;
ngramSize: string;
};
type: "wildcard";
}
Options for creating a Wildcard Analyzer.
+Type declaration
Optionalfeatures?: AnalyzerFeature[]Features to enable for this Analyzer.
+properties: {
analyzer?: Omit<CreateAnalyzerOptions, "features">;
ngramSize: string;
}Additional properties for the Analyzer.
+Optionalanalyzer?: Omit<CreateAnalyzerOptions, "features">An Analyzer definition-like object with
+typeandpropertiesattributes.ngram
Size: string N-gram length. Must be a positive integer greater than or equal to 2.
+
type: "wildcard"
Type of the Analyzer.
+
Type alias DelimiterAnalyzerDescription
properties: {
delimiter: string;
};
type: "delimiter";
}
An object describing a Delimiter Analyzer.
+Type declaration
properties: {
delimiter: string;
}delimiter: string
type: "delimiter"
Type alias GenericAnalyzerDescription
Shared attributes of all Analyzer descriptions.
+Type declaration
features: AnalyzerFeature[]
Features enabled for this Analyzer.
+name: string
A unique name for this Analyzer.
+
Type alias GeoJsonAnalyzerDescription
properties: {
description: {
maxCells: number;
maxLevel: number;
minLevel: number;
};
type: "shape" | "centroid" | "point";
};
type: "geojson";
}
An object describing a GeoJSON Analyzer
+Type declaration
properties: {
description: {
maxCells: number;
maxLevel: number;
minLevel: number;
};
type: "shape" | "centroid" | "point";
}description: {
maxCells: number;
maxLevel: number;
minLevel: number;
}max
Cells: number max
Level: number min
Level: number
type: "shape" | "centroid" | "point"
type: "geojson"
Type alias GeoPointAnalyzerDescription
properties: {
description: {
maxLevel: number;
minCells: number;
minLevel: number;
};
latitude: string[];
longitude: string[];
};
type: "geopoint";
}
An object describing a GeoPoint Analyzer
+Type declaration
properties: {
description: {
maxLevel: number;
minCells: number;
minLevel: number;
};
latitude: string[];
longitude: string[];
}description: {
maxLevel: number;
minCells: number;
minLevel: number;
}max
Level: number min
Cells: number min
Level: number
latitude: string[]
longitude: string[]
type: "geopoint"
Type alias GeoS2AnalyzerDescription
properties: {
description: {
maxCells: number;
maxLevel: number;
minLevel: number;
};
format: "latLngDouble" | "latLngInt" | "s2Point";
type: "shape" | "centroid" | "point";
};
type: "geo_s2";
}
(Enterprise Edition only.) An object describing a GeoS2 Analyzer
+Type declaration
properties: {
description: {
maxCells: number;
maxLevel: number;
minLevel: number;
};
format: "latLngDouble" | "latLngInt" | "s2Point";
type: "shape" | "centroid" | "point";
}description: {
maxCells: number;
maxLevel: number;
minLevel: number;
}max
Cells: number max
Level: number min
Level: number
format: "latLngDouble" | "latLngInt" | "s2Point"
type: "shape" | "centroid" | "point"
type: "geo_s2"
Type alias IdentityAnalyzerDescription
properties: Record<string, never>;
type: "identity";
}
An object describing an Identity Analyzer.
+Type declaration
properties: Record<string, never>
type: "identity"
Type alias MinHashAnalyzerDescription
properties: {
analyzer: Omit<AnalyzerDescription, "name" | "features">;
numHashes: number;
};
type: "minhash";
}
(Enterprise Edition only.) An object describing a MinHash Analyzer
+Type declaration
properties: {
analyzer: Omit<AnalyzerDescription, "name" | "features">;
numHashes: number;
}analyzer: Omit<AnalyzerDescription, "name" | "features">
num
Hashes: number
type: "minhash"
Type alias MultiDelimiterAnalyzerDescription
properties: {
delimiters: string[];
};
type: "multi_delimiter";
}
An object describing a Multi Delimiter Analyzer.
+Type declaration
properties: {
delimiters: string[];
}delimiters: string[]
type: "multi_delimiter"
Type alias NearestNeighborsAnalyzerDescription
properties: {
model_location: string;
top_k: number;
};
type: "nearest_neighbors";
}
(Enterprise Edition only.) An object describing a NearestNeighbors Analyzer
+Type declaration
properties: {
model_location: string;
top_k: number;
}model_
location: string top_
k: number
type: "nearest_neighbors"
Type alias NgramAnalyzerDescription
properties: {
max: number;
min: number;
preserveOriginal: boolean;
};
type: "ngram";
}
An object describing an Ngram Analyzer.
+Type declaration
properties: {
max: number;
min: number;
preserveOriginal: boolean;
}max: number
min: number
preserve
Original: boolean
type: "ngram"
Type alias NormAnalyzerDescription
properties: {
accent: boolean;
case: "lower" | "none" | "upper";
locale: string;
};
type: "norm";
}
An object describing a Norm Analyzer.
+Type declaration
properties: {
accent: boolean;
case: "lower" | "none" | "upper";
locale: string;
}accent: boolean
case: "lower" | "none" | "upper"
locale: string
type: "norm"
Type alias PipelineAnalyzerDescription
properties: {
pipeline: Omit<AnalyzerDescription, "name" | "features">[];
};
type: "pipeline";
}
An object describing a Pipeline Analyzer
+Type declaration
properties: {
pipeline: Omit<AnalyzerDescription, "name" | "features">[];
}pipeline: Omit<AnalyzerDescription, "name" | "features">[]
type: "pipeline"
Type alias SegmentationAnalyzerDescription
properties: {
break: "all" | "alpha" | "graphic";
case: "lower" | "upper" | "none";
};
type: "segmentation";
}
An object describing a Segmentation Analyzer
+Type declaration
properties: {
break: "all" | "alpha" | "graphic";
case: "lower" | "upper" | "none";
}break: "all" | "alpha" | "graphic"
case: "lower" | "upper" | "none"
type: "segmentation"
Type alias StemAnalyzerDescription
properties: {
locale: string;
};
type: "stem";
}
An object describing a Stem Analyzer.
+Type declaration
properties: {
locale: string;
}locale: string
type: "stem"
Type alias StopwordsAnalyzerDescription
properties: {
hex: boolean;
stopwords: string[];
};
type: "stopwords";
}
An object describing a Stopwords Analyzer
+Type declaration
properties: {
hex: boolean;
stopwords: string[];
}hex: boolean
stopwords: string[]
type: "stopwords"
Type alias TextAnalyzerDescription
properties: {
accent: boolean;
case: "lower" | "none" | "upper";
edgeNgram: {
max: number;
min: number;
preserveOriginal: boolean;
};
locale: string;
stemming: boolean;
stopwords: string[];
stopwordsPath: string;
};
type: "text";
}
An object describing a Text Analyzer.
+Type declaration
properties: {
accent: boolean;
case: "lower" | "none" | "upper";
edgeNgram: {
max: number;
min: number;
preserveOriginal: boolean;
};
locale: string;
stemming: boolean;
stopwords: string[];
stopwordsPath: string;
}accent: boolean
case: "lower" | "none" | "upper"
edge
Ngram: {
max: number;
min: number;
preserveOriginal: boolean;
}max: number
min: number
preserve
Original: boolean
locale: string
stemming: boolean
stopwords: string[]
stopwords
Path: string
type: "text"
Type alias WildcardAnalyzerDescription
properties: {
analyzer?: Omit<AnalyzerDescription, "name" | "features">;
ngramSize: number;
};
type: "wildcard";
}
An object describing a Wildcard Analyzer
+Type declaration
properties: {
analyzer?: Omit<AnalyzerDescription, "name" | "features">;
ngramSize: number;
}Optionalanalyzer?: Omit<AnalyzerDescription, "name" | "features">ngram
Size: number
type: "wildcard"
Type alias AqlValue
A value that can be used in an AQL template string or passed to an AQL +helper function.
+Type alias CollectionBatchReadOptions
allowDirtyRead?: boolean;
}
Options for retrieving multiple documents from a collection.
+Type declaration
OptionalallowDirty Read?: boolean If set to
+true, the request will explicitly permit ArangoDB to return a +potentially dirty or stale result and arangojs will load balance the +request without distinguishing between leaders and followers.
Type alias CollectionChecksumOptions
withData?: boolean;
withRevisions?: boolean;
}
Options for retrieving a collection checksum.
+Type declaration
OptionalwithData?: boolean If set to
+true, document data will be included in the calculation +of the checksum.Default:
+falseOptionalwithRevisions?: boolean If set to
+true, revision IDs will be included in the calculation +of the checksum.Default:
+false
Type alias CollectionDropOptions
isSystem?: boolean;
}
Options for dropping collections.
+Type declaration
OptionalisSystem?: boolean Whether the collection is a system collection. If the collection is a +system collection, this option must be set to
+trueor ArangoDB will +refuse to drop the collection.Default:
+false
Type alias CollectionEdgesOptions
allowDirtyRead?: boolean;
}
Options for retrieving a document's edges from a collection.
+Type declaration
OptionalallowDirty Read?: boolean If set to
+true, the request will explicitly permit ArangoDB to return a +potentially dirty or stale result and arangojs will load balance the +request without distinguishing between leaders and followers.
Type alias CollectionEdgesResult<T>
Result of retrieving edges in a collection.
+Type Parameters
Type alias CollectionImportOptions
complete?: boolean;
details?: boolean;
fromPrefix?: string;
onDuplicate?: "error" | "update" | "replace" | "ignore";
overwrite?: boolean;
toPrefix?: string;
waitForSync?: boolean;
}
Options for bulk importing documents into a collection.
+Type declaration
Optionalcomplete?: booleanIf set to
+true, the import will abort if any error occurs.Optionaldetails?: booleanWhether the response should contain additional details about documents +that could not be imported.
+OptionalfromPrefix?: string (Edge collections only.) Prefix to prepend to
+_fromattribute values.OptionalonDuplicate?: "error" | "update" | "replace" | "ignore" Controls behavior when a unique constraint is violated on the document key.
+-
+
"error": the document will not be imported.
+"update: the document will be merged into the existing document.
+"replace": the document will replace the existing document.
+"ignore": the document will not be imported and the unique constraint +error will be ignored.
+
Default:
+"error"Optionaloverwrite?: booleanIf set to
+true, the collection is truncated before the data is imported.Default:
+falseOptionaltoPrefix?: string (Edge collections only.) Prefix to prepend to
+_toattribute values.OptionalwaitFor Sync?: boolean Whether to wait for the documents to have been synced to disk.
+
Type alias CollectionImportResult
created: number;
details?: string[];
empty: number;
error: false;
errors: number;
ignored: number;
updated: number;
}
Result of a collection bulk import.
+Type declaration
created: number
Number of new documents imported.
+Optionaldetails?: string[]Additional details about any errors encountered during the import.
+empty: number
Number of empty documents.
+error: false
Whether the import failed.
+errors: number
Number of documents that failed with an error.
+ignored: number
Number of documents that failed with an error that is ignored.
+updated: number
Number of documents updated.
+
Type alias CollectionInsertOptions
mergeObjects?: boolean;
overwriteMode?: "ignore" | "update" | "replace" | "conflict";
refillIndexCaches?: boolean;
returnNew?: boolean;
returnOld?: boolean;
silent?: boolean;
versionAttribute?: string;
waitForSync?: boolean;
}
Options for inserting a new document into a collection.
+Type declaration
OptionalmergeObjects?: boolean If set to
+false, object properties that already exist in the old +document will be overwritten rather than merged when an existing document +with the same_keyor_idis updated. This does not affect arrays.Default:
+trueOptionaloverwriteMode?: "ignore" | "update" | "replace" | "conflict" Defines what should happen if a document with the same
+_keyor_id+already exists, instead of throwing an exception.Default: `"conflict"
+OptionalrefillIndex Caches?: boolean If set to
+true, new entries will be added to in-memory index caches if +document insertions affect the edge index or cache-enabled persistent +indexes.Default:
+falseOptionalreturnNew?: boolean If set to
+true, the complete new document will be returned as thenew+property on the result object. Has no effect ifsilentis set totrue.Default:
+falseOptionalreturnOld?: boolean If set to
+true, the complete old document will be returned as theold+property on the result object. Has no effect ifsilentis set totrue. +This option is only available whenoverwriteModeis set to"update"or +"replace".Default:
+falseOptionalsilent?: booleanIf set to
+true, no data will be returned by the server. This option can +be used to reduce network traffic.Default:
+falseOptionalversionAttribute?: string If set, the attribute with the name specified by the option is looked up +in the stored document and the attribute value is compared numerically to +the value of the versioning attribute in the supplied document that is +supposed to update/replace it.
+OptionalwaitFor Sync?: boolean If set to
+true, data will be synchronized to disk before returning.Default:
+false
Type alias CollectionKeyOptions
allowUserKeys?: boolean;
increment?: number;
offset?: number;
type?: KeyGenerator;
}
An object defining the collection's key generation.
+Type declaration
OptionalallowUser Keys?: boolean Unless set to
+false, documents can be created with a user-specified +_keyattribute.Default:
+trueOptionalincrement?: number(Autoincrement only.) How many steps to increment the key each time.
+Optionaloffset?: number(Autoincrement only.) Initial offset for the key.
+Optionaltype?: KeyGeneratorType of key generator to use.
+
Type alias CollectionKeyProperties
allowUserKeys: boolean;
increment?: number;
lastValue: number;
offset?: number;
type: KeyGenerator;
}
An object defining the collection's key generation.
+Type declaration
allow
User Keys: boolean Whether documents can be created with a user-specified
+_keyattribute.Optionalincrement?: number(Autoincrement only.) How many steps to increment the key each time.
+last
Value: number Most recent key that has been generated.
+Optionaloffset?: number(Autoincrement only.) Initial offset for the key.
+type: KeyGenerator
Type of key generator to use.
+
Type alias CollectionMetadata
globallyUniqueId: string;
name: string;
status: CollectionStatus;
type: CollectionType;
}
General information about a collection.
+Type declaration
globally
Unique Id: string A globally unique identifier for this collection.
+name: string
Collection name.
+status: CollectionStatus
An integer indicating the collection loading status.
+type: CollectionType
An integer indicating the collection type.
+
Type alias CollectionProperties
cacheEnabled: boolean;
computedValues: ComputedValueProperties[];
distributeShardsLike?: string;
isDisjoint?: string;
isSmart?: boolean;
keyOptions: CollectionKeyProperties;
numberOfShards?: number;
replicationFactor?: number | "satellite";
schema: SchemaProperties | null;
shardKeys?: string[];
shardingStrategy?: ShardingStrategy;
smartGraphAttribute?: string;
smartJoinAttribute?: string;
statusString: string;
syncByRevision: boolean;
waitForSync: boolean;
writeConcern: number;
}
An object defining the properties of a collection.
+Type declaration
cache
Enabled: boolean Whether the in-memory hash cache is enabled for this collection.
+computed
Values: ComputedValueProperties[] Computed values applied to documents in this collection.
+OptionaldistributeShards Like?: string (Enterprise Edition cluster only.) If set to a collection name, sharding +of the new collection will follow the rules for that collection. As long +as the new collection exists, the indicated collection can not be dropped.
+OptionalisDisjoint?: string (Enterprise Edition only.) Whether the SmartGraph this collection belongs to is disjoint.
+OptionalisSmart?: boolean (Enterprise Edition only.) Whether the collection is used in a SmartGraph or EnterpriseGraph.
+key
Options: CollectionKeyProperties An object defining the collection's key generation.
+OptionalnumberOf Shards?: number (Cluster only.) Number of shards of this collection.
+OptionalreplicationFactor?: number | "satellite" (Cluster only.) Replication factor of the collection.
+schema: SchemaProperties | null
Properties for validating documents in the collection.
+OptionalshardKeys?: string[] (Cluster only.) Keys of this collection that will be used for +sharding.
+OptionalshardingStrategy?: ShardingStrategy (Cluster only.) Sharding strategy of the collection.
+OptionalsmartGraph Attribute?: string (Enterprise Edition cluster only.) Attribute used for sharding.
+OptionalsmartJoin Attribute?: string (Enterprise Edition cluster only.) Attribute containing the shard key +value of the referred-to smart join collection.
+status
String: string A human-readable representation of the collection loading status.
+sync
By Revision: boolean Whether the newer revision-based replication protocol is enabled for +this collection.
+wait
For Sync: boolean Whether data should be synchronized to disk before returning from +a document create, update, replace or removal operation.
+write
Concern: number (Cluster only.) Write concern for this collection.
+
Type alias CollectionPropertiesOptions
cacheEnabled?: boolean;
computedValues?: ComputedValueOptions[];
replicationFactor?: number | "satellite";
schema?: SchemaOptions;
waitForSync?: boolean;
writeConcern?: number;
}
Options for setting a collection's properties.
+See DocumentCollection#properties and EdgeCollection#properties.
+Type declaration
OptionalcacheEnabled?: boolean Whether the in-memory hash cache is enabled for this collection.
+Default:
+falseOptionalcomputedValues?: ComputedValueOptions[] Computed values to apply to documents in this collection.
+OptionalreplicationFactor?: number | "satellite" (Cluster only.) How many copies of each document should be kept in the +cluster.
+Default:
+1Optionalschema?: SchemaOptionsOptions for validating documents in this collection.
+OptionalwaitFor Sync?: boolean Whether data should be synchronized to disk before returning from +a document create, update, replace or removal operation.
+OptionalwriteConcern?: number (Cluster only.) Write concern for this collection.
+
Type alias CollectionReadOptions
allowDirtyRead?: boolean;
graceful?: boolean;
ifMatch?: string;
ifNoneMatch?: string;
}
Options for retrieving a document from a collection.
+Type declaration
OptionalallowDirty Read?: boolean If set to
+true, the request will explicitly permit ArangoDB to return a +potentially dirty or stale result and arangojs will load balance the +request without distinguishing between leaders and followers.Optionalgraceful?: booleanIf set to
+true,nullis returned instead of an exception being thrown +if the document does not exist.OptionalifMatch?: string If set to a document revision, the request will fail with an error if the +document exists but its
+_revdoes not match the given revision.OptionalifNone Match?: string If set to a document revision, the request will fail with an error if the +document exists and its
+_revmatches the given revision. Note that an +HttpErrorwith code 304 will be thrown instead of anArangoError.
Type alias CollectionRemoveOptions
ifMatch?: string;
refillIndexCaches?: boolean;
returnOld?: boolean;
silent?: boolean;
waitForSync?: boolean;
}
Options for removing a document from a collection.
+Type declaration
OptionalifMatch?: string If set to a document revision, the document will only be removed if its +
+_revmatches the given revision.OptionalrefillIndex Caches?: boolean If set to
+true, existing entries in in-memory index caches will be +deleted if document removals affect the edge index or cache-enabled +persistent indexes.Default:
+falseOptionalreturnOld?: boolean If set to
+true, the complete old document will be returned as theold+property on the result object. Has no effect ifsilentis set totrue.Default:
+falseOptionalsilent?: booleanIf set to
+true, no data will be returned by the server. This option can +be used to reduce network traffic.Default:
+falseOptionalwaitFor Sync?: boolean If set to
+true, changes will be synchronized to disk before returning.Default:
+false
Type alias CollectionReplaceOptions
ifMatch?: string;
ignoreRevs?: boolean;
refillIndexCaches?: boolean;
returnNew?: boolean;
returnOld?: boolean;
silent?: boolean;
versionAttribute?: string;
waitForSync?: boolean;
}
Options for replacing an existing document in a collection.
+Type declaration
OptionalifMatch?: string If set to a document revision, the document will only be replaced if its +
+_revmatches the given revision.OptionalignoreRevs?: boolean If set to
+false, the existing document will only be modified if its +_revproperty matches the same property on the new data.Default:
+trueOptionalrefillIndex Caches?: boolean If set to
+true, existing entries in in-memory index caches will be +updated if document replacements affect the edge index or cache-enabled +persistent indexes.Default:
+falseOptionalreturnNew?: boolean If set to
+true, the complete new document will be returned as thenew+property on the result object. Has no effect ifsilentis set totrue.Default:
+falseOptionalreturnOld?: boolean If set to
+true, the complete old document will be returned as theold+property on the result object. Has no effect ifsilentis set totrue.Default:
+falseOptionalsilent?: booleanIf set to
+true, no data will be returned by the server. This option can +be used to reduce network traffic.Default:
+falseOptionalversionAttribute?: string If set, the attribute with the name specified by the option is looked up +in the stored document and the attribute value is compared numerically to +the value of the versioning attribute in the supplied document that is +supposed to update/replace it.
+OptionalwaitFor Sync?: boolean If set to
+true, data will be synchronized to disk before returning.Default:
+false
Type alias CollectionUpdateOptions
ifMatch?: string;
ignoreRevs?: boolean;
keepNull?: boolean;
mergeObjects?: boolean;
refillIndexCaches?: boolean;
returnNew?: boolean;
returnOld?: boolean;
silent?: boolean;
versionAttribute?: string;
waitForSync?: boolean;
}
Options for updating a document in a collection.
+Type declaration
OptionalifMatch?: string If set to a document revision, the document will only be updated if its +
+_revmatches the given revision.OptionalignoreRevs?: boolean If set to
+false, the existing document will only be modified if its +_revproperty matches the same property on the new data.Default:
+trueOptionalkeepNull?: boolean If set to
+false, properties with a value ofnullwill be removed from +the new document.Default:
+trueOptionalmergeObjects?: boolean If set to
+false, object properties that already exist in the old +document will be overwritten rather than merged. This does not affect +arrays.Default:
+trueOptionalrefillIndex Caches?: boolean If set to
+true, existing entries in in-memory index caches will be +updated if document updates affect the edge index or cache-enabled +persistent indexes.Default:
+falseOptionalreturnNew?: boolean If set to
+true, the complete new document will be returned as thenew+property on the result object. Has no effect ifsilentis set totrue.Default:
+falseOptionalreturnOld?: boolean If set to
+true, the complete old document will be returned as theold+property on the result object. Has no effect ifsilentis set totrue.Default:
+falseOptionalsilent?: booleanIf set to
+true, no data will be returned by the server. This option can +be used to reduce network traffic.Default:
+falseOptionalversionAttribute?: string If set, the attribute with the name specified by the option is looked up +in the stored document and the attribute value is compared numerically to +the value of the versioning attribute in the supplied document that is +supposed to update/replace it.
+OptionalwaitFor Sync?: boolean If set to
+true, data will be synchronized to disk before returning.Default:
+false
Type alias ComputedValueOptions
computeOn?: WriteOperation[];
expression: string | AqlLiteral | AqlQuery;
failOnWarning?: boolean;
keepNull?: boolean;
name: string;
overwrite?: boolean;
}
Options for creating a computed value.
+Type declaration
OptionalcomputeOn?: WriteOperation[] Which operations should result in the value being computed.
+Default:
+["insert", "update", "replace"]expression: string | AqlLiteral | AqlQuery
AQL
+RETURNexpression that computes the value.Note that when passing an AQL query object, the
+bindVarswill be ignored.OptionalfailOn Warning?: boolean Whether the write operation should fail if the expression produces a +warning.
+Default:
+falseOptionalkeepNull?: boolean If set to
+false, the field will be unset if the expression evaluates to +null. Otherwise the field will be set to the valuenull. Has no effect +ifoverwriteis set tofalse.Default:
+truename: string
Name of the target attribute of the computed value.
+Optionaloverwrite?: booleanIf set to
+false, the computed value will not be applied if the +expression evaluates tonull.Default:
+true
Type alias ComputedValueProperties
computeOn: WriteOperation[];
expression: string;
failOnWarning: boolean;
keepNull: boolean;
name: string;
overwrite: boolean;
}
Properties defining a computed value.
+Type declaration
compute
On: WriteOperation[] Which operations should result in the value being computed.
+expression: string
AQL
+RETURNexpression that computes the value.fail
On Warning: boolean Whether the write operation should fail if the expression produces a +warning.
+keep
Null: boolean If set to
+false, the field will be unset if the expression evaluates to +null. Otherwise the field will be set to the valuenull. Has no effect +ifoverwriteis set tofalse.name: string
Name of the target attribute of the computed value.
+overwrite: boolean
If set to
+false, the computed value will not be applied if the +expression evaluates tonull.
Type alias CreateCollectionOptions
cacheEnabled?: boolean;
computedValues?: ComputedValueOptions[];
distributeShardsLike?: string;
enforceReplicationFactor?: boolean;
keyOptions?: CollectionKeyOptions;
numberOfShards?: number;
replicationFactor?: number;
schema?: SchemaOptions;
shardKeys?: string[];
shardingStrategy?: ShardingStrategy;
smartGraphAttribute?: string;
smartJoinAttribute?: string;
waitForSync?: boolean;
waitForSyncReplication?: boolean;
writeConcern?: number;
}
Options for creating a collection.
+See database.Database#createCollection, database.Database#createEdgeCollection +and DocumentCollection#create or EdgeCollection#create.
+Type declaration
OptionalcacheEnabled?: boolean Whether the in-memory hash cache is enabled for this collection.
+OptionalcomputedValues?: ComputedValueOptions[] Computed values to apply to documents in this collection.
+OptionaldistributeShards Like?: string (Enterprise Edition cluster only.) If set to a collection name, sharding +of the new collection will follow the rules for that collection. As long +as the new collection exists, the indicated collection can not be dropped.
+OptionalenforceReplication Factor?: boolean (Cluster only.) Unless set to
+false, the server will check whether +enough replicas are available at creation time and bail out otherwise.Default:
+trueOptionalkeyOptions?: CollectionKeyOptions An object defining the collection's key generation.
+OptionalnumberOf Shards?: number (Cluster only.) Number of shards to distribute the collection across.
+Default:
+1OptionalreplicationFactor?: number (Cluster only.) How many copies of each document should be kept in the +cluster.
+Default:
+1Optionalschema?: SchemaOptionsOptions for validating documents in the collection.
+OptionalshardKeys?: string[] (Cluster only.) Document attributes to use to determine the target shard +for each document.
+Default:
+["_key"]OptionalshardingStrategy?: ShardingStrategy (Cluster only.) Sharding strategy to use.
+OptionalsmartGraph Attribute?: string (Enterprise Edition cluster only.) Attribute used for sharding.
+OptionalsmartJoin Attribute?: string (Enterprise Edition cluster only.) Attribute containing the shard key +value of the referred-to smart join collection.
+OptionalwaitFor Sync?: boolean If set to
+true, data will be synchronized to disk before returning from +a document create, update, replace or removal operation.Default:
+falseOptionalwaitFor Sync Replication?: boolean (Cluster only.) Unless set to
+false, the server will wait for all +replicas to create the collection before returning.Default:
+trueOptionalwriteConcern?: number (Cluster only.) Write concern for this collection.
+
Type alias DocumentExistsOptions
ifMatch?: string;
ifNoneMatch?: string;
}
Options for checking whether a document exists in a collection.
+Type declaration
OptionalifMatch?: string If set to a document revision, the document will only match if its
+_rev+matches the given revision.OptionalifNone Match?: string If set to a document revision, the document will only match if its
+_rev+does not match the given revision.
Type alias DocumentOperationFailure
error: true;
errorMessage: string;
errorNum: number;
}
Represents a bulk operation failure for an individual document.
+Type declaration
error: true
Indicates that the operation failed.
+error
Message: string Human-readable description of the failure.
+error
Num: number Numeric representation of the failure.
+
Type alias DocumentOperationMetadata
Metadata returned by a document operation.
+Type declaration
Optional_oldRev?: string Revision of the document that was updated or replaced by this operation.
+
Type alias IndexListOptions
withHidden?: boolean;
withStats?: boolean;
}
Type declaration
OptionalwithHidden?: boolean If set to
+true, includes indexes that are not yet fully built but are +in the building phase.Default:
+false.OptionalwithStats?: boolean If set to
+true, includes additional information about each index.Default:
+false
Type alias KeyGenerator
Type of key generator.
+Type alias SchemaOptions
Options for validating collection documents.
+Type declaration
Optionallevel?: ValidationLevelWhen validation should be applied.
+Default:
+"strict"Optionalmessage?: stringMessage to be used if validation fails.
+rule: any
JSON Schema description of the validation schema for documents.
+
Type alias SchemaProperties
Properties for validating documents in a collection.
+Type declaration
level: ValidationLevel
When validation should be applied.
+message: string
Message to be used if validation fails.
+rule: any
JSON Schema description of the validation schema for documents.
+type: "json"
Type of document validation.
+
Type alias ShardingStrategy
Strategy for sharding a collection.
+Type alias ValidationLevel
When a validation should be applied.
+-
+
"none": No validation.
+"new": Newly inserted documents are validated.
+"moderate": New and modified documents are validated unless the modified +document was already invalid.
+"strict": New and modified documents are always validated.
+
Type alias WriteOperation
Write operation that can result in a computed value being computed.
+Type alias ArangoApiResponse<T>
Extends the given base type T with the generic HTTP API response properties.
Type Parameters
Type alias ArangoResponseMetadata
code: number;
error: false;
}
Generic properties shared by all ArangoDB HTTP API responses.
+Type declaration
code: number
Response status code, typically
+200.error: false
Indicates that the request was successful.
+
Type alias BasicAuthCredentials
password?: string;
username: string;
}
Credentials for HTTP Basic authentication.
+Type declaration
Optionalpassword?: stringPassword to use for authentication. Defaults to an empty string.
+username: string
Username to use for authentication, e.g.
+"root".
Type alias BearerAuthCredentials
token: string;
}
Credentials for HTTP Bearer token authentication.
+Type declaration
token: string
Bearer token to use for authentication.
+
Type alias Config
afterResponse?: ((err, res?) => void);
arangoVersion?: number;
auth?: BasicAuthCredentials | BearerAuthCredentials;
beforeRequest?: ((req) => void);
credentials?: "omit" | "include" | "same-origin";
databaseName?: string;
headers?: Headers | Record<string, string>;
keepalive?: boolean;
loadBalancingStrategy?: LoadBalancingStrategy;
maxRetries?: false | number;
poolSize?: number;
precaptureStackTraces?: boolean;
responseQueueTimeSamples?: number;
retryOnConflict?: number;
url?: string | string[];
}
Options for configuring arangojs.
+Type declaration
OptionalafterResponse?: ((err, res?) => void) Callback that will be invoked when the server response has been received +and processed or when the request has been failed without a response.
+The originating request will be available as the
+requestproperty +on either the error or response object.- (err, res?): void
Parameters
- err: ArangojsError | null
Error encountered when handling this request or
+null. Optionalres: ArangojsResponseResponse object for this request, if no error occurred.
+
Returns void
- err: ArangojsError | null
OptionalarangoVersion?: number Numeric representation of the ArangoDB version the driver should expect. +The format is defined as
+XYYZZwhereXis the major version,Yis +the zero-filled two-digit minor version andZis the zero-filled two-digit +bugfix version, e.g.30102for 3.1.2,20811for 2.8.11.Depending on this value certain methods may become unavailable or change +their behavior to remain compatible with different versions of ArangoDB.
+Default:
+31100Optionalauth?: BasicAuthCredentials | BearerAuthCredentialsCredentials to use for authentication.
+See also database.Database#useBasicAuth and +database.Database#useBearerAuth.
+Default:
+{ username: "root", password: "" }OptionalbeforeRequest?: ((req) => void) Callback that will be invoked with the finished request object before it +is finalized. In the browser the request may already have been sent.
+- (req): void
Parameters
- req: globalThis.Request
Request object or XHR instance used for this request.
+
Returns void
- req: globalThis.Request
Optionalcredentials?: "omit" | "include" | "same-origin"(Browser only.) Determines whether credentials (e.g. cookies) will be sent +with requests to the ArangoDB server.
+If set to
+same-origin, credentials will only be included with requests +on the same URL origin as the invoking script. If set toinclude, +credentials will always be sent. If set toomit, credentials will be +excluded from all requests.Default:
+same-originOptionaldatabaseName?: string Name of the database to use.
+Default:
+"_system"Optionalheaders?: Headers | Record<string, string>An object with additional headers to send with every request.
+If an
+"authorization"header is provided, it will be overridden when +using database.Database#useBasicAuth, database.Database#useBearerAuth or +theauthconfiguration option.Optionalkeepalive?: booleanIf set to
+true, requests will keep the underlying connection open until +it times out or is closed. In browsers this prevents requests from being +cancelled when the user navigates away from the page.Default:
+trueOptionalloadBalancing Strategy?: LoadBalancingStrategy Determines the behavior when multiple URLs are provided:
+-
+
+"NONE": No load balancing. All requests will be handled by the first +URL in the list until a network error is encountered. On network error, +arangojs will advance to using the next URL in the list.
+
+"ONE_RANDOM": Randomly picks one URL from the list initially, then +behaves like"NONE".
+
+"ROUND_ROBIN": Every sequential request uses the next URL in the list.
+
Default:
+"NONE"OptionalmaxRetries?: false | number Determines the behavior when a request fails because the underlying +connection to the server could not be opened +(i.e.
+ECONNREFUSEDin Node.js):-
+
+false: the request fails immediately.
+
+0: the request is retried until a server can be reached but only a +total number of times matching the number of known servers (including +the initial failed request).
+any other number: the request is retried until a server can be reached +or the request has been retried a total of
+maxRetriesnumber of times +(not including the initial failed request).
+
When working with a single server, the retries (if any) will be made to +the same server.
+This setting currently has no effect when using arangojs in a browser.
+Note: Requests bound to a specific server (e.g. fetching query results) +will never be retried automatically and ignore this setting.
+Note: To set the number of retries when a write-write conflict is +encountered, see
+retryOnConflictinstead.Default:
+0OptionalpoolSize?: number Maximum number of parallel requests arangojs will perform. If any +additional requests are attempted, they will be enqueued until one of the +active requests has completed.
+Note: when using
+ROUND_ROBINload balancing and passing an array of +URLs in theurloption, the default value of this option will be set to +3 * url.lengthinstead of3.Default:
+3OptionalprecaptureStack Traces?: boolean If set to
+true, arangojs will generate stack traces every time a request +is initiated and augment the stack traces of any errors it generates.Warning: This will cause arangojs to generate stack traces in advance +even if the request does not result in an error. Generating stack traces +may negatively impact performance.
+OptionalresponseQueue Time Samples?: number Limits the number of values of server-reported response queue times that +will be stored and accessible using database.Database#queueTime. If set to +a finite value, older values will be discarded to make room for new values +when that limit is reached.
+Default:
+10OptionalretryOn Conflict?: number If set to a positive number, requests will automatically be retried at +most this many times if they result in a write-write conflict.
+Default:
+0Optionalurl?: string | string[]Base URL of the ArangoDB server or list of server URLs.
+When working with a cluster, the method database.Database#acquireHostList +can be used to automatically pick up additional coordinators/followers at +any point.
+When running ArangoDB on a unix socket, e.g.
+/tmp/arangodb.sock, the +following URL formats are supported for unix sockets:-
+
unix:///tmp/arangodb.sock(no SSL)
+http+unix:///tmp/arangodb.sock(orhttps+unix://for SSL)
+http://unix:/tmp/arangodb.sock(orhttps://unix:for SSL)
+
Additionally
+sslandtlsare treated as synonymous withhttpsand +tcpis treated as synonymous withhttp, so the following URLs are +considered identical:-
+
tcp://127.0.0.1:8529andhttp://127.0.0.1:8529
+ssl://127.0.0.1:8529andhttps://127.0.0.1:8529
+tcp+unix:///tmp/arangodb.sockandhttp+unix:///tmp/arangodb.sock
+ssl+unix:///tmp/arangodb.sockandhttps+unix:///tmp/arangodb.sock
+tcp://unix:/tmp/arangodb.sockandhttp://unix:/tmp/arangodb.sock
+ssl://unix:/tmp/arangodb.sockandhttps://unix:/tmp/arangodb.sock
+
See also
+authfor passing authentication credentials.Default:
+"http://127.0.0.1:8529"
Type alias LoadBalancingStrategy
Determines the behavior when multiple URLs are used:
+-
+
+"NONE": No load balancing. All requests will be handled by the first +URL in the list until a network error is encountered. On network error, +arangojs will advance to using the next URL in the list.
+
+"ONE_RANDOM": Randomly picks one URL from the list initially, then +behaves like"NONE".
+
+"ROUND_ROBIN": Every sequential request uses the next URL in the list.
+
Type alias RequestOptions
allowDirtyRead?: boolean;
basePath?: string;
body?: any;
expectBinary?: boolean;
headers?: Headers | Record<string, string>;
isBinary?: boolean;
method?: string;
path?: string;
retryOnConflict?: number;
search?: URLSearchParams | Record<string, any>;
timeout?: number;
}
Options for performing a request with arangojs.
+Type declaration
OptionalallowDirty Read?: boolean Whether ArangoDB is allowed to perform a dirty read to respond to this +request. If set to
+true, the response may reflect a dirty state from +a non-authoritative server.OptionalbasePath?: string Optional prefix path to prepend to the
+path.Optionalbody?: anyRequest body data.
+OptionalexpectBinary?: boolean If set to
+true, the response body will not be interpreted as JSON and +instead passed as-is.Optionalheaders?: Headers | Record<string, string>HTTP headers to pass along with this request in addition to the default +headers generated by arangojs.
+OptionalisBinary?: boolean If set to
+true, the request body will not be converted to JSON and +instead passed as-is.Optionalmethod?: stringHTTP method to use in order to perform the request.
+Default:
+"GET"Optionalpath?: stringURL path, relative to the
+basePathand server domain.OptionalretryOn Conflict?: number If set to a positive number, the request will automatically be retried at +most this many times if it results in a write-write conflict.
+Default:
+config.retryOnConflictOptionalsearch?: URLSearchParams | Record<string, any>URL parameters to pass as part of the query string.
+Optionaltimeout?: numberTime in milliseconds after which arangojs will abort the request if the +socket has not already timed out.
+See also
+agentOptions.timeoutin Config.
Type alias AccessLevel
Access level for an ArangoDB user's access to a collection or database.
+Type alias AqlUserFunction
code: string;
isDeterministic: boolean;
name: string;
}
Definition of an AQL User Function.
+Type declaration
code: string
Implementation of the AQL User Function.
+is
Deterministic: boolean Whether the function is deterministic.
+ +name: string
Name of the AQL User Function.
+
Type alias ArangoUser
active: boolean;
extra: Record<string, any>;
user: string;
}
Properties of an ArangoDB user object.
+Type declaration
active: boolean
Whether the ArangoDB user account is enabled and can authenticate.
+extra: Record<string, any>
Additional information to store about this user.
+user: string
ArangoDB username of the user.
+
Type alias ClusterImbalanceInfo
leader: {
imbalance: number;
leaderDupl: number[];
numberShards: number[];
targetWeight: number[];
totalShards: number;
totalWeight: number;
weightUsed: number[];
};
shards: {
imbalance: number;
numberShards: number[];
sizeUsed: number[];
targetSize: number[];
totalShards: number;
totalShardsFromSystemCollections: number;
totalUsed: number;
};
}
Information about a cluster imbalance.
+Type declaration
leader: {
imbalance: number;
leaderDupl: number[];
numberShards: number[];
targetWeight: number[];
totalShards: number;
totalWeight: number;
weightUsed: number[];
}Information about the leader imbalance.
+imbalance: number
The measure of the total imbalance. A high value indicates a high imbalance.
+leader
Dupl: number[] The measure of the leader shard distribution. The higher the number, the worse the distribution.
+number
Shards: number[] The number of leader shards per DB-Server.
+target
Weight: number[] The ideal weight of leader shards per DB-Server.
+total
Shards: number The sum of shards, counting leader shards only.
+total
Weight: number The sum of all weights.
+weight
Used: number[] The weight of leader shards per DB-Server. A leader has a weight of 1 by default but it is higher if collections can only be moved together because of
+distributeShardsLike.
shards: {
imbalance: number;
numberShards: number[];
sizeUsed: number[];
targetSize: number[];
totalShards: number;
totalShardsFromSystemCollections: number;
totalUsed: number;
}Information about the shard imbalance.
+imbalance: number
The measure of the total imbalance. A high value indicates a high imbalance.
+number
Shards: number[] The number of leader and follower shards per DB-Server.
+size
Used: number[] The size of shards per DB-Server.
+target
Size: number[] The ideal size of shards per DB-Server.
+total
Shards: number The sum of shards, counting leader and follower shards.
+total
Shards From System Collections: number The sum of system collection shards, counting leader shards only.
+total
Used: number The sum of the sizes.
+
Type alias ClusterRebalanceMove
collection: number;
from: string;
isLeader: boolean;
shard: string;
to: string;
}
Type declaration
collection: number
Collection ID of the collection the shard belongs to.
+from: string
The server name from which to move.
+is
Leader: boolean True if this is a leader move shard operation.
+shard: string
Shard ID of the shard to be moved.
+to: string
The ID of the destination server.
+
Type alias ClusterRebalanceOptions
databasesExcluded?: string[];
excludeSystemCollections?: boolean;
leaderChanges?: boolean;
maximumNumberOfMoves?: number;
moveFollowers?: boolean;
moveLeaders?: boolean;
piFactor?: number;
}
Options for rebalancing the cluster.
+Type declaration
OptionaldatabasesExcluded?: string[] A list of database names to exclude from the analysis.
+Default:
+[]OptionalexcludeSystem Collections?: boolean Ignore system collections in the rebalance plan.
+Default:
+falseOptionalleaderChanges?: boolean Allow leader changes without moving data.
+Default:
+trueOptionalmaximumNumber Of Moves?: number Maximum number of moves to be computed.
+Default:
+1000OptionalmoveFollowers?: boolean Allow moving followers.
+Default:
+falseOptionalmoveLeaders?: boolean Allow moving leaders.
+Default:
+falseOptionalpiFactor?: number Default:
+256**6
Type alias ClusterRebalanceResult
imbalanceAfter: ClusterImbalanceInfo;
imbalanceBefore: ClusterImbalanceInfo;
moves: ClusterRebalanceMove[];
}
Type declaration
imbalance
After: ClusterImbalanceInfo Expected imbalance after the suggested move shard operations are applied.
+imbalance
Before: ClusterImbalanceInfo Imbalance before the suggested move shard operations are applied.
+moves: ClusterRebalanceMove[]
Suggested move shard operations.
+
Type alias ClusterRebalanceState
pendingMoveShards: number;
todoMoveShards: number;
}
Information about the current state of the cluster imbalance.
+Type declaration
pending
Move Shards: number The number of pending move shard operations.
+todo
Move Shards: number The number of planned move shard operations.
+
Type alias CreateDatabaseOptions
replicationFactor?: "satellite" | number;
sharding?: "" | "flexible" | "single";
users?: CreateDatabaseUser[];
writeConcern?: number;
}
Options for creating a database.
+ +Type declaration
OptionalreplicationFactor?: "satellite" | number (Cluster only.) Default replication factor for new collections in this +database.
+Setting this to
+1disables replication. Setting this to"satellite"+will replicate to every DBServer.Optionalsharding?: "" | "flexible" | "single"(Cluster only.) The sharding method to use for new collections in the +database.
+Optionalusers?: CreateDatabaseUser[]Database users to create with the database.
+OptionalwriteConcern?: number (Cluster only.) Default write concern for new collections created in this +database.
+
Type alias CreateDatabaseUser
active?: boolean;
extra?: Record<string, any>;
passwd?: string;
username: string;
}
Database user to create with a database.
+Type declaration
Optionalactive?: booleanWhether the user is active.
+Default:
+trueOptionalextra?: Record<string, any>Additional data to store with the user object.
+Optionalpasswd?: stringPassword of the user to create.
+Default:
+""username: string
Username of the user to create.
+
Type alias CreateUserOptions
active?: boolean;
extra?: Record<string, any>;
passwd: string;
user: string;
}
Options for creating an ArangoDB user.
+Type declaration
Optionalactive?: booleanWhether the ArangoDB user account is enabled and can authenticate.
+Default:
+trueOptionalextra?: Record<string, any>Additional information to store about this user.
+Default:
+{}passwd: string
Password the ArangoDB user will use for authentication.
+user: string
ArangoDB username of the user.
+
Type alias DatabaseInfo
id: string;
isSystem: boolean;
name: string;
path: string;
replicationFactor?: "satellite" | number;
sharding?: "" | "flexible" | "single";
writeConcern?: number;
}
Object describing a database.
+See Database#get.
+Type declaration
id: string
Unique identifier of the database.
+is
System: boolean Whether the database is the system database.
+name: string
Name of the database.
+path: string
File system path of the database.
+OptionalreplicationFactor?: "satellite" | number (Cluster only.) Default replication factor for new collections in this +database.
+Optionalsharding?: "" | "flexible" | "single"(Cluster only.) The sharding method to use for new collections in the +database.
+OptionalwriteConcern?: number (Cluster only.) Default write concern for new collections created in this +database.
+
Type alias ExplainOptions
allPlans?: boolean;
maxNumberOfPlans?: number;
optimizer?: {
rules: string[];
};
}
Options for explaining a query.
+See Database#explain.
+Type declaration
OptionalallPlans?: boolean If set to true, all possible execution plans will be returned as the +
+plansproperty. Otherwise only the optimal execution plan will be +returned as theplanproperty.Default:
+falseOptionalmaxNumber Of Plans?: number Maximum number of plans that the optimizer is allowed to generate. +Setting this to a low value limits the amount of work the optimizer does.
+Optionaloptimizer?: {
rules: string[];
}An object with a
+rulesproperty specifying a list of optimizer rules to +be included or excluded by the optimizer for this query. Prefix a rule +name with+to include it, or-to exclude it. The nameallacts as +an alias matching all optimizer rules.rules: string[]
Type alias ExplainPlan
collections: {
name: string;
type: "read" | "write";
}[];
estimatedCost: number;
estimatedNrItems: number;
isModificationQuery: boolean;
nodes: {
dependencies: number[];
estimatedCost: number;
estimatedNrItems: number;
id: number;
type: string;
[key: string]: any;
}[];
rules: string[];
variables: {
id: number;
name: string;
}[];
}
Plan explaining query execution.
+Type declaration
collections: {
name: string;
type: "read" | "write";
}[]Information about collections involved in the query.
+estimated
Cost: number Total estimated cost of the plan.
+estimated
Nr Items: number Estimated number of items returned by the query.
+is
Modification Query: boolean Whether the query is a data modification query.
+nodes: {
dependencies: number[];
estimatedCost: number;
estimatedNrItems: number;
id: number;
type: string;
[key: string]: any;
}[]Execution nodes in this plan.
+rules: string[]
Rules applied by the optimizer.
+variables: {
id: number;
name: string;
}[]Variables used in the query.
+
Type alias ExplainStats
executionTime: number;
peakMemoryUsage: number;
plansCreated: number;
rulesExecuted: number;
rulesSkipped: number;
}
Optimizer statistics for an explained query.
+Type declaration
execution
Time: number Time in seconds needed to explain the query.
+peak
Memory Usage: number Maximum memory usage in bytes of the query during explain.
+plans
Created: number Total number of plans created.
+rules
Executed: number Total number of rules executed for this query.
+rules
Skipped: number Number of rules skipped for this query.
+
Type alias HotBackupList
list: Record<string, HotBackupResult & {
available: boolean;
countIncludesFilesOnly: boolean;
keys: any[];
nrPiecesPresent: number;
version: string;
}>;
server: string;
}
(Enterprise Edition only.) List of known hot backups.
+Type declaration
list: Record<string, HotBackupResult & {
available: boolean;
countIncludesFilesOnly: boolean;
keys: any[];
nrPiecesPresent: number;
version: string;
}>server: string
Type alias HotBackupOptions
allowInconsistent?: boolean;
force?: boolean;
label?: string;
timeout?: number;
}
(Enterprise Edition only.) Options for creating a hot backup.
+Type declaration
OptionalallowInconsistent?: boolean If set to
+trueand no global transaction lock can be acquired within the +given timeout, a possibly inconsistent backup is taken.Default:
+falseOptionalforce?: boolean(Enterprise Edition cluster only.) If set to
+trueand no global +transaction lock can be acquired within the given timeout, all running +transactions are forcefully aborted to ensure that a consistent backup +can be created.Default:
+false.Optionallabel?: stringLabel to appended to the backup's identifier.
+Default: If omitted or empty, a UUID will be generated.
+Optionaltimeout?: numberTime in seconds that the operation will attempt to get a consistent +snapshot.
+Default:
+120.
Type alias HotBackupResult
datetime: string;
id: string;
nrDBServers: number;
nrFiles: number;
potentiallyInconsistent: boolean;
sizeInBytes: number;
}
(Enterprise Edition only.) Result of a hot backup.
+Type declaration
datetime: string
id: string
nrDBServers: number
nr
Files: number potentially
Inconsistent: boolean size
In Bytes: number
Type alias InstallServiceOptions
configuration?: Record<string, any>;
dependencies?: Record<string, string>;
development?: boolean;
legacy?: boolean;
setup?: boolean;
}
Options for installing the service.
+ +Type declaration
Optionalconfiguration?: Record<string, any>An object mapping configuration option names to values.
+See also Database#getServiceConfiguration.
+Optionaldependencies?: Record<string, string>An object mapping dependency aliases to mount points.
+See also Database#getServiceDependencies.
+Optionaldevelopment?: booleanWhether the service should be installed in development mode.
+See also Database#setServiceDevelopmentMode.
+Default:
+falseOptionallegacy?: booleanWhether the service should be installed in legacy compatibility mode
+This overrides the
+enginesoption in the service manifest (if any).Default:
+falseOptionalsetup?: booleanWhether the "setup" script should be executed.
+Default:
+true
Type alias LogEntries
level: LogLevel[];
lid: number[];
text: string[];
timestamp: number[];
topic: string[];
totalAmount: number;
}
An object representing a list of log entries.
+Type declaration
level: LogLevel[]
lid: number[]
text: string[]
timestamp: number[]
topic: string[]
total
Amount: number
Type alias LogEntriesOptions
level?: LogLevel | LogLevelLabel | Lowercase<LogLevelLabel>;
offset?: number;
search?: string;
size?: number;
sort?: LogSortDirection;
start?: number;
upto?: LogLevel | LogLevelLabel | Lowercase<LogLevelLabel>;
}
Options for retrieving log entries.
+Type declaration
Optionallevel?: LogLevel | LogLevelLabel | Lowercase<LogLevelLabel>If set, only log entries with this log level will be returned.
+Optionaloffset?: numberIf set, this many log entries will be skipped.
+Optionalsearch?: stringIf set, only log entries containing the specified text will be returned.
+Optionalsize?: numberIf set, only this many entries will be returned.
+Optionalsort?: LogSortDirectionIf set to
+"desc", log entries will be returned in reverse chronological +order.Default:
+"asc".Optionalstart?: numberIf set, only log entries with an
+lidgreater than or equal to this value +will be returned.Optionalupto?: LogLevel | LogLevelLabel | Lowercase<LogLevelLabel>Maximum log level of the entries to retrieve.
+Default:
+INFO.
Type alias LogLevelLabel
String representation of the logging level of a log entry.
+Type alias LogMessage
An object representing a single log entry.
+Type declaration
date: string
id: number
level: LogLevelLabel
message: string
topic: string
Type alias LogSortDirection
Log sorting direction, ascending or descending.
+Type alias MultiExplainResult
cacheable: boolean;
plans: ExplainPlan[];
stats: ExplainStats;
warnings: {
code: number;
message: string;
}[];
}
Result of explaining a query with multiple plans.
+Type declaration
cacheable: boolean
Whether it would be possible to cache the query.
+plans: ExplainPlan[]
Query plans.
+stats: ExplainStats
Optimizer statistics for the explained query.
+warnings: {
code: number;
message: string;
}[]Warnings encountered while planning the query execution.
+
Type alias MultiServiceDependency
current?: string[];
description?: string;
multiple: true;
name: string;
required: boolean;
title: string;
version: string;
}
Object describing a multi-service dependency defined by a Foxx service.
+Type declaration
Optionalcurrent?: string[]Current mount points the dependency is resolved to.
+Optionaldescription?: stringHuman-readable description of the dependency.
+multiple: true
Whether this is a multi-service dependency.
+name: string
Name of the service the dependency expects to match.
+required: boolean
Whether the dependency must be matched in order for the service +to be operational.
+title: string
Formatted name of the dependency.
+version: string
Version of the service the dependency expects to match.
+
Type alias ParseResult
Result of parsing a query.
+Type declaration
ast: AstNode[]
Abstract syntax tree (AST) of the query.
+bind
Vars: string[] Names of all bind parameters used in the query.
+collections: string[]
Names of all collections involved in the query.
+parsed: boolean
Whether the query was parsed.
+
Type alias QueryInfo
bindVars: Record<string, any>;
database: string;
id: string;
peakMemoryUsage: number;
query: string;
runTime: number;
started: string;
state: "executing" | "finished" | "killed";
stream: boolean;
user: string;
}
Object describing a query.
+Type declaration
bind
Vars: Record<string, any> Bind parameters used in the query.
+database: string
Name of the database the query runs in.
+id: string
Unique identifier for this query.
+peak
Memory Usage: number Maximum memory usage in bytes of the query.
+query: string
Query string (potentially truncated).
+run
Time: number Query's running time in seconds.
+started: string
Date and time the query was started.
+state: "executing" | "finished" | "killed"
Query's current execution state.
+stream: boolean
Whether the query uses a streaming cursor.
+user: string
Name of the user that started the query.
+
Type alias QueryOptimizerRule
flags: {
canBeDisabled: boolean;
canCreateAdditionalPlans: boolean;
clusterOnly: boolean;
disabledByDefault: boolean;
enterpriseOnly: boolean;
hidden: boolean;
};
name: string;
}
Optimizer rule for AQL queries.
+Type declaration
flags: {
canBeDisabled: boolean;
canCreateAdditionalPlans: boolean;
clusterOnly: boolean;
disabledByDefault: boolean;
enterpriseOnly: boolean;
hidden: boolean;
}can
Be Disabled: boolean can
Create Additional Plans: boolean cluster
Only: boolean disabled
By Default: boolean enterprise
Only: boolean hidden: boolean
name: string
Type alias QueryOptions
allowDirtyRead?: boolean;
allowRetry?: boolean;
batchSize?: number;
cache?: boolean;
count?: boolean;
failOnWarning?: boolean;
fillBlockCache?: boolean;
fullCount?: boolean;
intermediateCommitCount?: number;
intermediateCommitSize?: number;
maxNodesPerCallstack?: number;
maxPlans?: number;
maxRuntime?: number;
maxTransactionSize?: number;
maxWarningsCount?: number;
memoryLimit?: number;
optimizer?: {
rules: string[];
};
profile?: boolean | number;
retryOnConflict?: number;
satelliteSyncWait?: number;
skipInaccessibleCollections?: boolean;
stream?: boolean;
timeout?: number;
ttl?: number;
}
Options for executing a query.
+See Database#query.
+Type declaration
OptionalallowDirty Read?: boolean If set to
+true, the query will be executed with support for dirty reads +enabled, permitting ArangoDB to return a potentially dirty or stale result +and arangojs will load balance the request without distinguishing between +leaders and followers.Note that dirty reads are only supported for read-only queries, not data +modification queries (e.g. using
+INSERT,UPDATE,REPLACEor +REMOVE) and only when using ArangoDB 3.4 or later.Default:
+falseOptionalallowRetry?: boolean If set to
+true, cursor results will be stored by ArangoDB in such a way +that batch reads can be retried in the case of a communication error.Default:
+falseOptionalbatchSize?: number Number of result values to be transferred by the server in each +network roundtrip (or "batch").
+Must be greater than zero.
+Optionalcache?: booleanIf set to
+false, the AQL query results cache lookup will be skipped for +this query.Default:
+trueOptionalcount?: booleanUnless set to
+false, the number of result values in the result set will +be returned in thecountattribute. This may be disabled by default in +a future version of ArangoDB if calculating this value has a performance +impact for some queries.Default:
+true.OptionalfailOn Warning?: boolean If set to
+true, the query will throw an exception and abort if it would + otherwise produce a warning.OptionalfillBlock Cache?: boolean If set to
+false, the query data will not be stored in the RocksDB block +cache. This can be used to avoid thrashing he block cache when reading a +lot of data.OptionalfullCount?: boolean If set to
+trueand the query has aLIMITclause, the total number of +values matched before the last top-levelLIMITin the query was applied +will be returned in theextra.stats.fullCountattribute.OptionalintermediateCommit Count?: number Maximum number of operations after which an intermediate commit is +automatically performed.
+OptionalintermediateCommit Size?: number Maximum total size of operations in bytes after which an intermediate +commit is automatically performed.
+OptionalmaxNodes Per Callstack?: number Controls after how many execution nodes in a query a stack split should be +performed.
+Default:
+250(200on macOS)OptionalmaxPlans?: number Limits the maximum number of plans that will be created by the AQL query +optimizer.
+OptionalmaxRuntime?: number Maximum allowed execution time before the query will be killed in seconds.
+If set to
+0, the query will be allowed to run indefinitely.Default:
+0OptionalmaxTransaction Size?: number Maximum size of transactions in bytes.
+OptionalmaxWarnings Count?: number Limits the maximum number of warnings a query will return.
+OptionalmemoryLimit?: number Maximum memory size in bytes that the query is allowed to use. +Exceeding this value will result in the query failing with an error.
+If set to
+0, the memory limit is disabled.Default:
+0Optionaloptimizer?: {
rules: string[];
}An object with a
+rulesproperty specifying a list of optimizer rules to +be included or excluded by the optimizer for this query. Prefix a rule +name with+to include it, or-to exclude it. The nameallacts as +an alias matching all optimizer rules.rules: string[]
Optionalprofile?: boolean | numberIf set to
+1ortrue, additional query profiling information will be +returned in theextra.profileattribute if the query is not served from +the result cache.If set to
+2, the query will return execution stats per query plan node +in theextra.stats.nodesattribute. Additionally the query plan is +returned inextra.plan.OptionalretryOn Conflict?: number If set to a positive number, the query will automatically be retried at +most this many times if it results in a write-write conflict.
+Default:
+0OptionalsatelliteSync Wait?: number (Enterprise Edition cluster only.) Limits the maximum time in seconds a +DBServer will wait to bring satellite collections involved in the query +into sync. Exceeding this value will result in the query being stopped.
+Default:
+60OptionalskipInaccessible Collections?: boolean (Enterprise Edition cluster only.) If set to
+true, collections +inaccessible to current user will result in an access error instead +of being treated as empty.Optionalstream?: booleanIf set to
+true, the query will be executed as a streaming query.Optionaltimeout?: numberMaximum time in milliseconds arangojs will wait for a server response. +Exceeding this value will result in the request being cancelled.
+Note: Setting a timeout for the client does not guarantee the query +will be killed by ArangoDB if it is already being executed. See the +
+maxRuntimeoption for limiting the execution time within ArangoDB.Optionalttl?: numberTime-to-live for the cursor in seconds. The cursor results may be +garbage collected by ArangoDB after this much time has passed.
+Default:
+30
Type alias QueryTracking
enabled: boolean;
maxQueryStringLength: number;
maxSlowQueries: number;
slowQueryThreshold: number;
trackBindVars: boolean;
trackSlowQueries: boolean;
}
Information about query tracking.
+Type declaration
enabled: boolean
Whether query tracking is enabled.
+max
Query String Length: number Maximum query string length in bytes that is kept in the list.
+max
Slow Queries: number Maximum number of slow queries that is kept in the list.
+slow
Query Threshold: number Threshold execution time in seconds for when a query is +considered slow.
+track
Bind Vars: boolean Whether bind parameters are being tracked along with queries.
+track
Slow Queries: boolean Whether slow queries are being tracked.
+
Type alias QueryTrackingOptions
enabled?: boolean;
maxQueryStringLength?: number;
maxSlowQueries?: number;
slowQueryThreshold?: number;
trackBindVars?: boolean;
trackSlowQueries?: boolean;
}
Options for query tracking.
+ +Type declaration
Optionalenabled?: booleanIf set to
+false, neither queries nor slow queries will be tracked.OptionalmaxQuery String Length?: number Maximum query string length in bytes that will be kept in the list.
+OptionalmaxSlow Queries?: number Maximum number of slow queries to be kept in the list.
+OptionalslowQuery Threshold?: number Threshold execution time in seconds for when a query will be +considered slow.
+OptionaltrackBind Vars?: boolean If set to
+true, bind parameters will be tracked along with queries.OptionaltrackSlow Queries?: boolean If set to
+trueandenabledis also set totrue, slow queries will be +tracked if their execution time exceedsslowQueryThreshold.
Type alias QueueTimeMetrics
getAvg: (() => number);
getLatest: (() => number | undefined);
getValues: (() => [number, number][]);
}
An object providing methods for accessing queue time metrics of the most +recently received server responses if the server supports this feature.
+Type declaration
get
Avg: (() => number) Returns the average queue time of the most recently received responses +in seconds.
+- (): number
Returns number
get
Latest: (() => number | undefined) Returns the queue time of the most recently received response in seconds.
+- (): number | undefined
Returns number | undefined
get
Values: (() => [number, number][]) Returns a list of the most recently received queue time values as tuples +of the timestamp of the response being processed in milliseconds and the +queue time in seconds.
+- (): [number, number][]
Returns [number, number][]
Type alias ReplaceServiceOptions
configuration?: Record<string, any>;
dependencies?: Record<string, string>;
development?: boolean;
force?: boolean;
legacy?: boolean;
setup?: boolean;
teardown?: boolean;
}
Options for replacing a service.
+ +Type declaration
Optionalconfiguration?: Record<string, any>An object mapping configuration option names to values.
+See also Database#getServiceConfiguration.
+Optionaldependencies?: Record<string, string>An object mapping dependency aliases to mount points.
+See also Database#getServiceDependencies.
+Optionaldevelopment?: booleanWhether the service should be installed in development mode.
+See also Database#setServiceDevelopmentMode.
+Default:
+falseOptionalforce?: booleanIf set to
+true, replacing a service that does not already exist will +fall back to installing the new service.Default:
+falseOptionallegacy?: booleanWhether the service should be installed in legacy compatibility mode
+This overrides the
+enginesoption in the service manifest (if any).Default:
+falseOptionalsetup?: booleanWhether the "setup" script should be executed.
+Default:
+trueOptionalteardown?: booleanWhether the existing service's "teardown" script should be executed +prior to removing that service.
+Default:
+true
Type alias ServiceConfiguration
current: any;
currentRaw: any;
default?: any;
description?: string;
required: boolean;
title: string;
type: "integer" | "boolean" | "string" | "number" | "json" | "password" | "int" | "bool";
}
Object describing a configuration option of a Foxx service.
+Type declaration
current: any
Processed current value of the configuration option as exposed in the +service code.
+current
Raw: any Current value of the configuration option as stored internally.
+Optionaldefault?: anyDefault value of the configuration option.
+Optionaldescription?: stringHuman-readable description of the configuration option.
+required: boolean
Whether the configuration option must be set in order for the service +to be operational.
+title: string
Formatted name of the configuration option.
+type: "integer" | "boolean" | "string" | "number" | "json" | "password" | "int" | "bool"
Data type of the configuration value.
+Note:
+"int"and"bool"are historical synonyms for"integer"and +"boolean". The"password"type is synonymous with"string"but can +be used to distinguish values which should not be displayed in plain text +by software when managing the service.
Type alias ServiceInfo
checksum: string;
development: boolean;
legacy: boolean;
manifest: FoxxManifest;
mount: string;
name?: string;
options: {
configuration: Record<string, any>;
dependencies: Record<string, string>;
};
path: string;
version?: string;
}
Object describing a Foxx service in detail.
+Type declaration
checksum: string
Internal checksum of the service's initial source bundle.
+development: boolean
Whether development mode is enabled for this service.
+legacy: boolean
Whether the service is running in legacy compatibility mode.
+manifest: FoxxManifest
Content of the service manifest of this service.
+mount: string
Service mount point, relative to the database.
+Optionalname?: stringName defined in the service manifest.
+options: {
configuration: Record<string, any>;
dependencies: Record<string, string>;
}Options for this service.
+configuration: Record<string, any>
Configuration values set for this service.
+dependencies: Record<string, string>
Service dependency configuration of this service.
+
path: string
File system path of the service.
+Optionalversion?: stringVersion defined in the service manifest.
+
Type alias ServiceSummary
development: boolean;
legacy: boolean;
mount: string;
name?: string;
provides: Record<string, string>;
version?: string;
}
Object briefly describing a Foxx service.
+Type declaration
development: boolean
Whether development mode is enabled for this service.
+legacy: boolean
Whether the service is running in legacy compatibility mode.
+mount: string
Service mount point, relative to the database.
+Optionalname?: stringName defined in the service manifest.
+provides: Record<string, string>
Service dependencies the service expects to be able to match as a mapping +from dependency names to versions the service is compatible with.
+Optionalversion?: stringVersion defined in the service manifest.
+
Type alias ServiceTestDefaultReport
failures: ServiceTestDefaultTest[];
passes: ServiceTestDefaultTest[];
pending: ServiceTestDefaultTest[];
stats: ServiceTestStats;
tests: ServiceTestDefaultTest[];
}
Test results for a Foxx service's tests using the default reporter.
+Type declaration
failures: ServiceTestDefaultTest[]
passes: ServiceTestDefaultTest[]
pending: ServiceTestDefaultTest[]
stats: ServiceTestStats
tests: ServiceTestDefaultTest[]
Type alias ServiceTestDefaultTest
duration: number;
err?: string;
fullTitle: string;
title: string;
}
Test results for a single test case using the default reporter.
+Type declaration
duration: number
Optionalerr?: stringfull
Title: string title: string
Type alias ServiceTestStats
duration: number;
failures: number;
passes: number;
pending: number;
tests: number;
}
Test stats for a Foxx service's tests.
+Type declaration
duration: number
Total test duration in milliseconds.
+failures: number
Number of tests that failed.
+passes: number
Number of tests that ran successfully.
+pending: number
Number of tests skipped or not executed.
+tests: number
Total number of tests found.
+
Type alias ServiceTestStreamReport
total: number;
}] | ["pass", ServiceTestStreamTest] | ["fail", ServiceTestStreamTest] | ["end", ServiceTestStats])[]
Test results for a Foxx service's tests using the stream reporter.
+Type alias ServiceTestStreamTest
duration: number;
err?: string;
fullTitle: string;
title: string;
}
Test results for a single test case using the stream reporter.
+Type declaration
duration: number
Optionalerr?: stringfull
Title: string title: string
Type alias ServiceTestSuite
Test results for a single test suite using the suite reporter.
+Type declaration
suites: ServiceTestSuite[]
tests: ServiceTestSuiteTest[]
title: string
Type alias ServiceTestSuiteReport
stats: ServiceTestStats;
suites: ServiceTestSuite[];
tests: ServiceTestSuiteTest[];
}
Test results for a Foxx service's tests using the suite reporter.
+Type declaration
stats: ServiceTestStats
suites: ServiceTestSuite[]
tests: ServiceTestSuiteTest[]
Type alias ServiceTestSuiteTest
duration: number;
err?: any;
result: "pending" | "pass" | "fail";
title: string;
}
Test results for a single test case using the suite reporter.
+Type declaration
duration: number
Optionalerr?: anyresult: "pending" | "pass" | "fail"
title: string
Type alias ServiceTestTapReport
Test results for a Foxx service's tests in TAP format.
+Type alias ServiceTestXunitReport
errors: number;
failures: number;
skip: number;
tests: number;
time: number;
timestamp: number;
}, ...ServiceTestXunitTest[]]
Test results for a Foxx service's tests in XUnit format using the JSONML +representation.
+Type declaration
errors: number
failures: number
skip: number
tests: number
time: number
timestamp: number
Type alias ServiceTestXunitTest
classname: string;
name: string;
time: number;
}] | ["testcase", {
classname: string;
name: string;
time: number;
}, ["failure", {
message: string;
type: string;
}, string]]
Test results for a single test case in XUnit format using the JSONML +representation.
+Type alias SingleExplainResult
cacheable: boolean;
plan: ExplainPlan;
stats: ExplainStats;
warnings: {
code: number;
message: string;
}[];
}
Result of explaining a query with a single plan.
+Type declaration
cacheable: boolean
Whether it would be possible to cache the query.
+plan: ExplainPlan
Query plan.
+stats: ExplainStats
Optimizer statistics for the explained query.
+warnings: {
code: number;
message: string;
}[]Warnings encountered while planning the query execution.
+
Type alias SingleServiceDependency
current?: string;
description?: string;
multiple: false;
name: string;
required: boolean;
title: string;
version: string;
}
Object describing a single-service dependency defined by a Foxx service.
+Type declaration
Optionalcurrent?: stringCurrent mount point the dependency is resolved to.
+Optionaldescription?: stringHuman-readable description of the dependency.
+multiple: false
Whether this is a multi-service dependency.
+name: string
Name of the service the dependency expects to match.
+required: boolean
Whether the dependency must be matched in order for the service +to be operational.
+title: string
Formatted name of the dependency.
+version: string
Version of the service the dependency expects to match.
+
Type alias SwaggerJson
info: {
description: string;
license: string;
title: string;
version: string;
};
path: {
[key: string]: any;
};
[key: string]: any;
}
OpenAPI 2.0 description of a Foxx service.
+Type declaration
[key: string]: any
info: {
description: string;
license: string;
title: string;
version: string;
}description: string
license: string
title: string
version: string
path: {
[key: string]: any;
}[key: string]: any
Type alias TransactionCollections
exclusive?: (string | ArangoCollection)[] | string | ArangoCollection;
read?: (string | ArangoCollection)[] | string | ArangoCollection;
write?: (string | ArangoCollection)[] | string | ArangoCollection;
}
Collections involved in a transaction.
+Type declaration
Optionalexclusive?: (string | ArangoCollection)[] | string | ArangoCollectionAn array of collections or a single collection that will be read from or +written to during the transaction with no other writes being able to run +in parallel.
+Optionalread?: (string | ArangoCollection)[] | string | ArangoCollectionAn array of collections or a single collection that will be read from +during the transaction.
+Optionalwrite?: (string | ArangoCollection)[] | string | ArangoCollectionAn array of collections or a single collection that will be read from or +written to during the transaction.
+
Type alias TransactionDetails
id: string;
state: "running" | "committed" | "aborted";
}
Details for a transaction.
+See also transaction.TransactionStatus.
+Type declaration
id: string
Unique identifier of the transaction.
+state: "running" | "committed" | "aborted"
Status (or "state") of the transaction.
+
Type alias TransactionOptions
allowDirtyRead?: boolean;
allowImplicit?: boolean;
lockTimeout?: number;
maxTransactionSize?: number;
skipFastLockRound?: boolean;
waitForSync?: boolean;
}
Options for how the transaction should be performed.
+Type declaration
OptionalallowDirty Read?: boolean If set to
+true, the request will explicitly permit ArangoDB to return a +potentially dirty or stale result and arangojs will load balance the +request without distinguishing between leaders and followers.OptionalallowImplicit?: boolean Whether the transaction may read from collections not specified for this +transaction. If set to
+false, accessing any collections not specified +will result in the transaction being aborted to avoid potential deadlocks.Default:
+true.OptionallockTimeout?: number Determines how long the database will wait while attempting to gain locks +on collections used by the transaction before timing out.
+OptionalmaxTransaction Size?: number Determines the transaction size limit in bytes.
+OptionalskipFast Lock Round?: boolean If set to
+true, the fast lock round will be skipped, which makes each +locking operation take longer but guarantees deterministic locking order +and may avoid deadlocks when many concurrent transactions are queued and +try to access the same collection with an exclusive lock.OptionalwaitFor Sync?: boolean Determines whether to force the transaction to write all data to disk +before returning.
+
Type alias UninstallServiceOptions
force?: boolean;
teardown?: boolean;
}
Options for uninstalling a service.
+ +Type declaration
Optionalforce?: booleanIf set to
+true, uninstalling a service that does not already exist +will be considered successful.Default:
+falseOptionalteardown?: booleanWhether the service's "teardown" script should be executed +prior to removing that service.
+Default:
+true
Type alias UpgradeServiceOptions
configuration?: Record<string, any>;
dependencies?: Record<string, string>;
development?: boolean;
force?: boolean;
legacy?: boolean;
setup?: boolean;
teardown?: boolean;
}
Options for upgrading a service.
+ +Type declaration
Optionalconfiguration?: Record<string, any>An object mapping configuration option names to values.
+See also Database#getServiceConfiguration.
+Optionaldependencies?: Record<string, string>An object mapping dependency aliases to mount points.
+See also Database#getServiceDependencies.
+Optionaldevelopment?: booleanWhether the service should be installed in development mode.
+See also Database#setServiceDevelopmentMode.
+Default:
+falseOptionalforce?: booleanUnless set to
+true, upgrading a service that does not already exist will +fall back to installing the new service.Default:
+falseOptionallegacy?: booleanWhether the service should be installed in legacy compatibility mode
+This overrides the
+enginesoption in the service manifest (if any).Default:
+falseOptionalsetup?: booleanWhether the "setup" script should be executed.
+Default:
+trueOptionalteardown?: booleanWhether the existing service's "teardown" script should be executed +prior to upgrading that service.
+Default:
+false
Type alias UserAccessLevelOptions
Options for accessing or manipulating access levels.
+Type declaration
Optionalcollection?: ArangoCollection | stringThe collection to access or manipulate the access level of.
+Optionaldatabase?: Database | stringThe database to access or manipulate the access level of.
+If
+collectionis anArangoCollection, this option defaults to the +database the collection is contained in. Otherwise this option defaults to +the current database.
Type alias UserOptions
active?: boolean;
extra?: Record<string, any>;
passwd: string;
}
Options for modifying an ArangoDB user.
+Type declaration
Optionalactive?: booleanWhether the ArangoDB user account is enabled and can authenticate.
+Default:
+trueOptionalextra?: Record<string, any>Additional information to store about this user.
+Default:
+{}passwd: string
Password the ArangoDB user will use for authentication.
+
Type alias VersionInfo
details?: {
[key: string]: string;
};
license: "community" | "enterprise";
server: string;
version: string;
}
Result of retrieving database version information.
+Type declaration
Optionaldetails?: {
[key: string]: string;
}Additional information about the ArangoDB server.
+[key: string]: string
license: "community" | "enterprise"
ArangoDB license type or "edition".
+server: string
Value identifying the server type, i.e.
+"arango".version: string
ArangoDB server version.
+
Type alias Document<T>
Type representing a document stored in a collection.
+Type Parameters
Type alias DocumentData<T>
Type representing an object that can be stored in a collection.
+Type Parameters
Type alias DocumentMetadata
_id: string;
_key: string;
_rev: string;
}
Common ArangoDB metadata properties of a document.
+Type declaration
_id: string
Unique ID of the document, which is composed of the collection name +and the document
+_key._key: string
Key of the document, which uniquely identifies the document within its +collection.
+_rev: string
Revision of the document data.
+
Type alias DocumentSelector
A value that can be used to identify a document within a collection in
+arangojs methods, i.e. a partial ArangoDB document or the value of a
+document's _key or _id.
Type alias Edge<T>
Type representing an edge document stored in an edge collection.
+Type Parameters
Type alias EdgeData<T>
Type representing an object that can be stored in an edge collection.
+Type Parameters
Type alias EdgeMetadata
_from: string;
_to: string;
}
ArangoDB metadata defining the relations of an edge document.
+Type declaration
_from: string
Unique ID of the document that acts as the edge's start vertex.
+_to: string
Unique ID of the document that acts as the edge's end vertex.
+
Type alias ObjectWithId
_id: string;
[key: string]: any;
}
An object with an ArangoDB document _id property.
Type declaration
[key: string]: any
_id: string
Type alias ObjectWithKey
_key: string;
[key: string]: any;
}
An object with an ArangoDB document _key property.
Type declaration
[key: string]: any
_key: string
Type alias Patch<T>
Type representing patch data for a given object type to represent a payload +ArangoDB can apply in a document PATCH request (i.e. a partial update).
+This differs from Partial in that it also applies itself to any nested
+objects recursively.
Type Parameters
Type alias Configuration
default?: any;
description?: string;
required?: boolean;
type: "integer" | "boolean" | "number" | "string" | "json" | "password" | "int" | "bool";
}
A configuration option.
+Type declaration
Optionaldefault?: anyThe default value for this option in plain JSON. Can be omitted to provide no default value.
+Optionaldescription?: stringA human-readable description of the option.
+Optionalrequired?: booleanWhether the service can not function without this option. Defaults to true unless a default value is provided.
+type: "integer" | "boolean" | "number" | "string" | "json" | "password" | "int" | "bool"
The type of value expected for this option.
+
Type alias Dependency
description?: string;
multiple?: boolean;
name?: string;
required?: boolean;
version?: string;
}
A service dependency.
+Type declaration
Optionaldescription?: stringA description of how the API is used or why it is needed.
+Optionalmultiple?: booleanWhether the dependency can be specified more than once.
+Optionalname?: stringName of the API the service expects.
+Optionalrequired?: booleanWhether the service can not function without this dependency.
+Optionalversion?: stringThe semantic version ranges of the API the service expects.
+
Type alias File
gzip?: boolean;
path: string;
type?: string;
}
A service file asset.
+Type declaration
Optionalgzip?: booleanIf set to true the file will be served with gzip-encoding if supported by the client. This can be useful when serving text files like client-side JavaScript, CSS or HTML.
+path: string
Relative path of the file or folder within the service.
+Optionaltype?: stringThe MIME content type of the file. Defaults to an intelligent guess based on the filename's extension.
+
Type alias FoxxManifest
author?: string;
configuration?: Record<string, Configuration>;
contributors?: string[];
defaultDocument?: string;
dependencies?: Record<string, string | Dependency>;
description?: string;
engines?: Record<string, string> & {
arangodb?: string;
};
files?: Record<string, string | File>;
keywords?: string[];
lib?: string;
license?: string;
main?: string;
name?: string;
provides?: Record<string, string>;
scripts?: Record<string, string>;
tests?: string | string[];
thumbnail?: string;
version?: string;
}
Schema for ArangoDB Foxx service manifests.
+Type declaration
Optionalauthor?: stringThe full name of the author of the service (i.e. you). This will be shown in the web interface.
+Optionalconfiguration?: Record<string, Configuration>An object defining the configuration options this service requires.
+Optionalcontributors?: string[]A list of names of people that have contributed to the development of the service in some way. This will be shown in the web interface.
+OptionaldefaultDocument?: string If specified, the / (root) route of the service will automatically redirect to the given relative path, e.g. "index.html".
+Optionaldependencies?: Record<string, string | Dependency>The dependencies this service uses, i.e. which APIs its dependencies need to be compatible with.
+Optionaldescription?: stringA human-readable description of the service. This will be shown in the web interface.
+Optionalengines?: Record<string, string> & {
arangodb?: string;
}An object indicating the semantic version ranges of ArangoDB (or compatible environments) the service will be compatible with.
+Optionalfiles?: Record<string, string | File>An object defining file assets served by this service.
+Optionalkeywords?: string[]A list of keywords that help categorize this service. This is used by the Foxx Store installers to organize services.
+Optionallib?: stringThe relative path to the Foxx JavaScript files in the service, e.g. "lib". Defaults to the folder containing this manifest.
+Optionallicense?: stringA string identifying the license under which the service is published, ideally in the form of an SPDX license identifier. This will be shown in the web interface.
+Optionalmain?: stringThe relative path to the main entry point of this service (relative to lib), e.g. "index.js".
+Optionalname?: stringThe name of the Foxx service. This will be shown in the web interface.
+Optionalprovides?: Record<string, string>The dependencies this provides, i.e. which APIs it claims to be compatible with.
+Optionalscripts?: Record<string, string>An object defining named scripts provided by this service, which can either be used directly or as queued jobs by other services.
+Optionaltests?: string | string[]A path/pattern or list of paths/patterns of JavaScript tests provided for this service.
+Optionalthumbnail?: stringThe filename of a thumbnail that will be used alongside the service in the web interface. This should be a JPEG or PNG image that looks good at sizes 50x50 and 160x160.
+Optionalversion?: stringThe version number of the Foxx service. The version number must follow the semantic versioning format. This will be shown in the web interface.
+
Type alias AddEdgeDefinitionOptions
Type declaration
Optionalsatellites?: (string | ArangoCollection)[](Enterprise Edition cluster only.) Collections to be included in a Hybrid +SmartGraph.
+
Type alias AddVertexCollectionOptions
Type declaration
Optionalsatellites?: (string | ArangoCollection)[](Enterprise Edition cluster only.) Collections to be included in a Hybrid +SmartGraph.
+
Type alias CreateGraphOptions
isDisjoint?: boolean;
isSmart?: boolean;
numberOfShards?: number;
orphanCollections?: (string | ArangoCollection)[] | string | ArangoCollection;
replicationFactor?: number | "satellite";
satellites?: (string | ArangoCollection)[];
smartGraphAttribute?: string;
waitForSync?: boolean;
writeConcern?: number;
}
Option for creating a graph.
+Type declaration
OptionalisDisjoint?: boolean (Enterprise Edition cluster only.) If set to
+true, the graph will be +created as a Disjoint SmartGraph.Default:
+falseOptionalisSmart?: boolean (Enterprise Edition cluster only.) If set to
+true, the graph will be +created as a SmartGraph.Default:
+falseOptionalnumberOf Shards?: number (Cluster only.) Number of shards that is used for every collection +within this graph.
+Has no effect when
+replicationFactoris set to"satellite".OptionalorphanCollections?: (string | ArangoCollection)[] | string | ArangoCollection Additional vertex collections. Documents within these collections do not +have edges within this graph.
+OptionalreplicationFactor?: number | "satellite" (Cluster only.) Replication factor used when initially creating +collections for this graph.
+Default:
+1Optionalsatellites?: (string | ArangoCollection)[](Enterprise Edition cluster only.) Collections to be included in a Hybrid +SmartGraph.
+OptionalsmartGraph Attribute?: string (Enterprise Edition cluster only.) Attribute containing the shard key +value to use for smart sharding.
+OptionalwaitFor Sync?: boolean If set to
+true, the request will wait until all modifications have been +synchronized to disk before returning successfully.Default:
+falseOptionalwriteConcern?: number (Cluster only.) Write concern for new collections in the graph.
+Has no effect when
+replicationFactoris set to"satellite".
Type alias EdgeDefinition
collection: string;
from: string[];
to: string[];
}
Definition of a relation in a graph.Graph.
+Type declaration
collection: string
Name of the collection containing the edges.
+from: string[]
Array of names of collections containing the start vertices.
+to: string[]
Array of names of collections containing the end vertices.
+
Type alias EdgeDefinitionOptions
collection: string | ArangoCollection;
from: (string | ArangoCollection)[] | string | ArangoCollection;
to: (string | ArangoCollection)[] | string | ArangoCollection;
}
An edge definition used to define a collection of edges in a graph.Graph.
+Type declaration
collection: string | ArangoCollection
Collection containing the edges.
+from: (string | ArangoCollection)[] | string | ArangoCollection
Collection or collections containing the start vertices.
+to: (string | ArangoCollection)[] | string | ArangoCollection
Collection or collections containing the end vertices.
+
Type alias GraphCollectionInsertOptions
returnNew?: boolean;
waitForSync?: boolean;
}
Options for inserting a document into a graph collection.
+Type declaration
OptionalreturnNew?: boolean If set to
+true, the complete new document will be returned as thenew+property on the result object.Default:
+falseOptionalwaitFor Sync?: boolean If set to
+true, data will be synchronized to disk before returning.Default:
+false
Type alias GraphCollectionReadOptions
allowDirtyRead?: boolean;
graceful?: boolean;
rev?: string;
}
Options for retrieving a document from a graph collection.
+Type declaration
OptionalallowDirty Read?: boolean If set to
+true, the request will explicitly permit ArangoDB to return a +potentially dirty or stale result and arangojs will load balance the +request without distinguishing between leaders and followers.Default:
+falseOptionalgraceful?: booleanIf set to
+true,nullis returned instead of an exception being thrown +if the document does not exist.Default:
+falseOptionalrev?: stringIf set to a document revision, the document will only be returned if its +
+_revproperty matches this value.See also documents.DocumentMetadata.
+
Type alias GraphCollectionRemoveOptions
returnOld?: boolean;
rev?: string;
waitForSync?: boolean;
}
Options for removing a document from a graph collection.
+Type declaration
OptionalreturnOld?: boolean If set to
+true, the complete old document will be returned as theold+property on the result object.Default:
+falseOptionalrev?: stringIf set to a document revision, the document will only be removed if its +
+_revproperty matches this value.See also documents.DocumentMetadata.
+OptionalwaitFor Sync?: boolean If set to
+true, data will be synchronized to disk before returning.Default:
+false
Type alias GraphCollectionReplaceOptions
keepNull?: boolean;
returnNew?: boolean;
returnOld?: boolean;
rev?: string;
waitForSync?: boolean;
}
Options for replacing a document in a graph collection.
+Type declaration
OptionalkeepNull?: boolean If set to
+false, properties with a value ofnullwill be removed from +the new document.Default:
+trueOptionalreturnNew?: boolean If set to
+true, the complete new document will be returned as thenew+property on the result object.Default:
+falseOptionalreturnOld?: boolean If set to
+true, the complete old document will be returned as theold+property on the result object.Default:
+falseOptionalrev?: stringIf set to a document revision, the document will only be modified if its +
+_revproperty matches this value.See also documents.DocumentMetadata.
+OptionalwaitFor Sync?: boolean If set to
+true, data will be synchronized to disk before returning.Default:
+false
Type alias GraphInfo
edgeDefinitions: EdgeDefinition[];
isDisjoint?: boolean;
isSatellite?: boolean;
isSmart?: boolean;
name: string;
numberOfShards?: number;
orphanCollections: string[];
replicationFactor?: number;
smartGraphAttribute?: string;
writeConcern?: number;
}
General information about a graph.
+Type declaration
edge
Definitions: EdgeDefinition[] Definitions for the relations of the graph.
+OptionalisDisjoint?: boolean (Enterprise Edition cluster only.) If set to
+true, the graph has been +created as a Disjoint SmartGraph.OptionalisSatellite?: boolean (Enterprise Edition cluster only.) If set to
+true, the graph is a +SatelliteGraph.OptionalisSmart?: boolean (Enterprise Edition cluster only.) If set to
+true, the graph has been +created as a SmartGraph.name: string
Name of the graph.
+OptionalnumberOf Shards?: number (Cluster only.) Number of shards that is used for every collection +within this graph.
+orphan
Collections: string[] Additional vertex collections. Documents within these collections do not +have edges within this graph.
+OptionalreplicationFactor?: number (Cluster only.) Replication factor used when initially creating +collections for this graph.
+OptionalsmartGraph Attribute?: string (Enterprise Edition cluster only.) Attribute containing the shard key +value to use for smart sharding.
+OptionalwriteConcern?: number (Cluster only.) Write concern for new collections in the graph.
+
Type alias ReplaceEdgeDefinitionOptions
satellites?: string[];
}
Type declaration
Optionalsatellites?: string[](Enterprise Edition cluster only.) Collections to be included in a Hybrid +SmartGraph.
+
Type alias EnsureGeoIndexOptions
fields: [string, string];
geoJson?: false;
inBackground?: boolean;
legacyPolygons?: boolean;
name?: string;
type: "geo";
} | {
fields: [string];
geoJson?: boolean;
inBackground?: boolean;
legacyPolygons?: boolean;
name?: string;
type: "geo";
}
Options for creating a geo index.
+Type declaration
fields: [string, string]
Attribute paths for the document's latitude and longitude values.
+OptionalgeoJson?: false If set to
+true,fieldsmust be an array containing a single attribute +path and the attribute value must be an array with two values, the first +of which will be interpreted as the longitude and the second of which will +be interpreted as the latitude of the document.Default:
+falseOptionalinBackground?: boolean If set to
+true, the index will be created in the background to reduce +the write-lock duration for the collection during index creation.Default:
+falseOptionallegacyPolygons?: boolean If set to
+true, the index will use pre-3.10 rules for parsing +GeoJSON polygons. This option is always implicitlytruewhen using +ArangoDB 3.9 or lower.Optionalname?: stringA unique name for this index.
+type: "geo"
Type declaration
fields: [string]
An array containing the attribute path for an array containing two values, +the first of which will be interpreted as the latitude, the second as the +longitude. If
+geoJsonis set totrue, the order is reversed to match +the GeoJSON format.OptionalgeoJson?: boolean If set to
+true,fieldsmust be an array containing a single attribute +path and the attribute value must be an array with two values, the first +of which will be interpreted as the longitude and the second of which will +be interpreted as the latitude of the document.Default:
+falseOptionalinBackground?: boolean If set to
+true, the index will be created in the background to reduce +the write-lock duration for the collection during index creation.Default:
+falseOptionallegacyPolygons?: boolean If set to
+true, the index will use pre-3.10 rules for parsing +GeoJSON polygons. This option is always implicitlytruewhen using +ArangoDB 3.9 or lower.Optionalname?: stringA unique name for this index.
+type: "geo"
Type alias EnsureIndexOptions
Options for creating an index.
+Type alias EnsureInvertedIndexOptions
analyzer?: string;
cache?: boolean;
cleanupIntervalStep?: number;
commitIntervalMsec?: number;
consolidationIntervalMsec?: number;
consolidationPolicy?: TierConsolidationPolicy;
features?: AnalyzerFeature[];
fields: (string | InvertedIndexFieldOptions)[];
inBackground?: boolean;
includeAllFields?: boolean;
name?: string;
optimizeTopK?: string[];
parallelism?: number;
primaryKeyCache?: boolean;
primarySort?: {
cache?: boolean;
compression?: Compression;
fields: InvertedIndexPrimarySortFieldOptions[];
};
searchField?: boolean;
storedValues?: InvertedIndexStoredValueOptions[];
trackListPositions?: boolean;
type: "inverted";
writeBufferActive?: number;
writeBufferIdle?: number;
writeBufferSizeMax?: number;
}
Options for creating an inverted index.
+Type declaration
Optionalanalyzer?: stringName of the default Analyzer to apply to the values of indexed fields.
+Default:
+"identity"Optionalcache?: boolean(Enterprise Edition only.) If set to
+true, then field normalization +values will always be cached in memory.Default:
+falseOptionalcleanupInterval Step?: number Wait at least this many commits between removing unused files in the +ArangoSearch data directory.
+Default:
+2OptionalcommitInterval Msec?: number Wait at least this many milliseconds between committing View data store +changes and making documents visible to queries.
+Default:
+1000OptionalconsolidationInterval Msec?: number Wait at least this many milliseconds between applying +
+consolidationPolicyto consolidate View data store and possibly release +space on the filesystem.Default:
+1000OptionalconsolidationPolicy?: TierConsolidationPolicy The consolidation policy to apply for selecting which segments should be +merged.
+Default:
+{ type: "tier" }Optionalfeatures?: AnalyzerFeature[]List of Analyzer features to enable for the default Analyzer.
+Defaults to the Analyzer's features.
+fields: (string | InvertedIndexFieldOptions)[]
An array of attribute paths or objects specifying options for the fields.
+OptionalinBackground?: boolean If set to
+true, the index will be created in the background to reduce +the write-lock duration for the collection during index creation.Default:
+falseOptionalincludeAll Fields?: boolean If set to
+true, all document attributes are indexed, excluding any +sub-attributes configured in thefieldsarray. Theanalyzerand +featuresproperties apply to the sub-attributes. This option only +applies when using the index in a SearchAlias View.Default:
+falseOptionalname?: stringA unique name for this index.
+OptionaloptimizeTopK?: string[] An array of strings defining sort expressions to optimize.
+Optionalparallelism?: numberThe number of threads to use for indexing the fields.
+Default:
+2OptionalprimaryKey Cache?: boolean (Enterprise Edition only.) If set to
+true, then the primary key column +will always be cached in memory.Default:
+falseOptionalprimarySort?: {
cache?: boolean;
compression?: Compression;
fields: InvertedIndexPrimarySortFieldOptions[];
}Primary sort order to optimize AQL queries using a matching sort order.
+Optionalcache?: boolean(Enterprise Edition only.) If set to
+true, then primary sort columns +will always be cached in memory.Default:
+falseOptionalcompression?: CompressionHow the primary sort data should be compressed.
+Default:
+"lz4"fields: InvertedIndexPrimarySortFieldOptions[]
An array of fields to sort the index by.
+
OptionalsearchField?: boolean If set to
+truearray values will by default be indexed using the same +behavior as ArangoSearch Views. This option only applies when using the +index in a SearchAlias View.Default:
+falseOptionalstoredValues?: InvertedIndexStoredValueOptions[] An array of attribute paths that will be stored in the index but can not +be used for index lookups or sorting but can avoid full document lookups.
+OptionaltrackList Positions?: boolean If set to
+true, the position of values in array values are tracked and +need to be specified in queries. Otherwise all values in an array are +treated as equivalent. This option only applies when using the index in a +SearchAlias View.Default:
+falsetype: "inverted"
Type of this index.
+OptionalwriteBuffer Active?: number Maximum number of concurrent active writers (segments) that perform a +transaction.
+Default:
+0(disabled)OptionalwriteBuffer Idle?: number Maximum number of writers (segments) cached in the pool.
+Default:
+64OptionalwriteBuffer Size Max?: number Maximum memory byte size per writer (segment) before a writer (segment) +flush is triggered.
+Default:
+33554432(32 MiB)
Type alias EnsureMdiIndexOptions
fieldValueTypes: "double";
fields: string[];
inBackground?: boolean;
name?: string;
type: "mdi";
unique?: boolean;
}
Options for creating a MDI index.
+Type declaration
field
Value Types: "double" Data type of the dimension attributes.
+fields: string[]
An array containing attribute paths for the dimensions.
+OptionalinBackground?: boolean If set to
+true, the index will be created in the background to reduce +the write-lock duration for the collection during index creation.Default:
+falseOptionalname?: stringA unique name for this index.
+type: "mdi"
Type of this index.
+Optionalunique?: booleanIf set to
+true, a unique index will be created.Default:
+false
Type alias EnsurePersistentIndexOptions
cacheEnabled?: boolean;
deduplicate?: boolean;
estimates?: boolean;
fields: string[];
inBackground?: boolean;
name?: string;
sparse?: boolean;
storedValues?: string[];
type: "persistent";
unique?: boolean;
}
Options for creating a persistent index.
+Type declaration
OptionalcacheEnabled?: boolean If set to
+true, an in-memory hash cache will be put in front of the +persistent index.Default:
+falseOptionaldeduplicate?: booleanIf set to
+false, inserting duplicate index values from the same +document will lead to a unique constraint error if this is a unique index.Default:
+trueOptionalestimates?: booleanIf set to
+false, index selectivity estimates will be disabled for this +index.Default:
+truefields: string[]
An array of attribute paths.
+OptionalinBackground?: boolean If set to
+true, the index will be created in the background to reduce +the write-lock duration for the collection during index creation.Default:
+falseOptionalname?: stringA unique name for this index.
+Optionalsparse?: booleanIf set to
+true, the index will omit documents that do not contain at +least one of the attribute paths infieldsand these documents will be +ignored for uniqueness checks.Default:
+falseOptionalstoredValues?: string[] An array of attribute paths that will be stored in the index but can not +be used for index lookups or sorting but can avoid full document lookups.
+type: "persistent"
Type of this index.
+Optionalunique?: booleanIf set to
+true, a unique index will be created.Default:
+false
Type alias EnsureTtlIndexOptions
expireAfter: number;
fields: [string];
inBackground?: boolean;
name?: string;
type: "ttl";
}
Options for creating a TTL index.
+Type declaration
expire
After: number Duration in seconds after the attribute value at which the document will +be considered as expired.
+fields: [string]
An array containing exactly one attribute path.
+OptionalinBackground?: boolean If set to
+true, the index will be created in the background to reduce +the write-lock duration for the collection during index creation.Default:
+falseOptionalname?: stringA unique name for this index.
+type: "ttl"
Type of this index.
+
Type alias GenericIndex
figures?: Record<string, any>;
id: string;
name: string;
progress?: number;
sparse: boolean;
unique: boolean;
}
Shared attributes of all index types.
+Type declaration
Optionalfigures?: Record<string, any>Additional stats about this index.
+id: string
A unique identifier for this index.
+name: string
A unique name for this index.
+Optionalprogress?: numberProgress of this index if it is still being created.
+sparse: boolean
Whether documents not containing at least one of the attribute paths +are omitted by this index.
+unique: boolean
Whether this index enforces uniqueness for values of its attribute paths.
+
Type alias GeoIndex
bestIndexedLevel: number;
fields: [string] | [string, string];
geoJson: boolean;
legacyPolygons: boolean;
maxNumCoverCells: number;
type: "geo";
worstIndexedLevel: number;
}
An object representing a geo index.
+Type declaration
best
Indexed Level: number fields: [string] | [string, string]
geo
Json: boolean legacy
Polygons: boolean max
Num Cover Cells: number type: "geo"
worst
Indexed Level: number
Type alias Index
An object representing an index.
+Type alias IndexDetails
Type declaration
Optionalfigures?: Record<string, any>Optionalprogress?: number
Type alias IndexSelector
Index name, id or object with a name or id property.
Type alias InvertedIndex
analyzer: string;
cache?: boolean;
cleanupIntervalStep: number;
commitIntervalMsec: number;
consolidationIntervalMsec: number;
consolidationPolicy: Required<TierConsolidationPolicy>;
features: AnalyzerFeature[];
fields: {
analyzer?: string;
cache?: boolean;
features?: AnalyzerFeature[];
includeAllFields?: boolean;
name: string;
nested?: InvertedIndexNestedField[];
searchField?: boolean;
trackListPositions?: boolean;
}[];
includeAllFields: boolean;
optimizeTopK: string[];
parallelism: number;
primaryKeyCache?: boolean;
primarySort: {
cache?: boolean;
compression: Compression;
fields: {
direction: Direction;
field: string;
}[];
};
searchField: boolean;
storedValues: {
cache?: boolean;
compression: Compression;
fields: string[];
}[];
trackListPositions: boolean;
type: "inverted";
writeBufferActive: number;
writeBufferIdle: number;
writeBufferSizeMax: number;
}
An object representing an inverted index.
+Type declaration
analyzer: string
Optionalcache?: booleancleanup
Interval Step: number commit
Interval Msec: number consolidation
Interval Msec: number consolidation
Policy: Required<TierConsolidationPolicy> features: AnalyzerFeature[]
fields: {
analyzer?: string;
cache?: boolean;
features?: AnalyzerFeature[];
includeAllFields?: boolean;
name: string;
nested?: InvertedIndexNestedField[];
searchField?: boolean;
trackListPositions?: boolean;
}[]include
All Fields: boolean optimize
TopK: string[] parallelism: number
OptionalprimaryKey Cache?: boolean primary
Sort: {
cache?: boolean;
compression: Compression;
fields: {
direction: Direction;
field: string;
}[];
}Optionalcache?: booleancompression: Compression
fields: {
direction: Direction;
field: string;
}[]
search
Field: boolean stored
Values: {
cache?: boolean;
compression: Compression;
fields: string[];
}[]track
List Positions: boolean type: "inverted"
write
Buffer Active: number write
Buffer Idle: number write
Buffer Size Max: number
Type alias InvertedIndexFieldOptions
analyzer?: string;
cache?: boolean;
features?: AnalyzerFeature[];
includeAllFields?: boolean;
name: string;
nested?: (string | InvertedIndexNestedFieldOptions)[];
searchField?: boolean;
trackListPositions?: boolean;
}
Options for an attribute path in an inverted index.
+Type declaration
Optionalanalyzer?: stringName of the Analyzer to apply to the values of this field.
+Defaults to the
+analyzerspecified on the index itself.Optionalcache?: boolean(Enterprise Edition only.) If set to
+true, then field normalization +values will always be cached in memory.Defaults to the value of
+cachespecified on the index itself.Optionalfeatures?: AnalyzerFeature[]List of Analyzer features to enable for this field's Analyzer.
+Defaults to the features of the Analyzer.
+OptionalincludeAll Fields?: boolean If set to
+true, all document attributes are indexed, excluding any +sub-attributes configured in thefieldsarray. Theanalyzerand +featuresproperties apply to the sub-attributes. This option only +applies when using the index in a SearchAlias View.Defaults to the value of
+includeAllFieldsspecified on the index itself.name: string
An attribute path.
+Optionalnested?: (string | InvertedIndexNestedFieldOptions)[](Enterprise Edition only.) Sub-objects to index to allow querying for +co-occurring values.
+OptionalsearchField?: boolean If set to
+truearray values will be indexed using the same behavior as +ArangoSearch Views. This option only applies when using the index in a +SearchAlias View.Defaults to the value of
+searchFieldspecified on the index itself.OptionaltrackList Positions?: boolean If set to
+true, the position of values in array values are tracked and +need to be specified in queries. Otherwise all values in an array are +treated as equivalent. This option only applies when using the index in a +SearchAlias View.Defaults to the value of
+trackListPositionsspecified on the index +itself.
Type alias InvertedIndexNestedField
analyzer?: string;
features?: AnalyzerFeature[];
name: string;
nested?: InvertedIndexNestedField[];
searchField?: boolean;
}
(Enterprise Edition only.) An object representing a nested field in an +inverted index.
+Type declaration
Optionalanalyzer?: stringOptionalfeatures?: AnalyzerFeature[]name: string
Optionalnested?: InvertedIndexNestedField[]OptionalsearchField?: boolean
Type alias InvertedIndexNestedFieldOptions
analyzer?: string;
features?: AnalyzerFeature[];
name: string;
nested?: (string | InvertedIndexNestedFieldOptions)[];
searchField?: boolean;
}
(Enterprise Edition only.) Options for a nested field in an inverted index.
+Type declaration
Optionalanalyzer?: stringName of the Analyzer to apply to the values of this field.
+Defaults to the
+analyzerspecified on the parent options or on the index +itself.Optionalfeatures?: AnalyzerFeature[]List of Analyzer features to enable for this field's Analyzer.
+Defaults to the features of the Analyzer.
+name: string
An attribute path.
+Optionalnested?: (string | InvertedIndexNestedFieldOptions)[]Sub-objects to index to allow querying for co-occurring values.
+OptionalsearchField?: boolean If set to
+truearray values will be indexed using the same behavior as +ArangoSearch Views. This option only applies when using the index in a +SearchAlias View.Defaults to the value of
+searchFieldspecified on the index itself.
Type alias InvertedIndexStoredValueOptions
Options for defining a stored value on an inverted index.
+Type declaration
Optionalcache?: boolean(Enterprise Edition only.) If set to
+true, then stored values will +always be cached in memory.Default:
+falseOptionalcompression?: CompressionHow the attribute values should be compressed.
+Default:
+"lz4"fields: string[]
The attribute paths to store.
+
Type alias MdiIndex
An object representing a MDI index.
+Type declaration
field
Value Types: "double" fields: string[]
type: "mdi"
Type alias ObjectWithId
id: string;
[key: string]: any;
}
Type declaration
[key: string]: any
id: string
Type alias ObjectWithName
name: string;
[key: string]: any;
}
Type declaration
[key: string]: any
name: string
Type alias PersistentIndex
cacheEnabled: boolean;
deduplicate: boolean;
estimates: boolean;
fields: string[];
storedValues?: string[];
type: "persistent";
}
An object representing a persistent index.
+Type declaration
cache
Enabled: boolean deduplicate: boolean
estimates: boolean
fields: string[]
OptionalstoredValues?: string[] type: "persistent"
Type alias PrimaryIndex
An object representing a primary index.
+Type declaration
fields: string[]
selectivity
Estimate: number type: "primary"
Type alias TtlIndex
expireAfter: number;
fields: [string];
selectivityEstimate: number;
type: "ttl";
}
An object representing a TTL index.
+Type declaration
expire
After: number fields: [string]
selectivity
Estimate: number type: "ttl"
Type alias TransactionAbortOptions
allowDirtyRead?: boolean;
}
Options for how the transaction should be aborted.
+Type declaration
OptionalallowDirty Read?: boolean If set to
+true, the request will explicitly permit ArangoDB to return a +potentially dirty or stale result and arangojs will load balance the +request without distinguishing between leaders and followers.
Type alias TransactionCommitOptions
allowDirtyRead?: boolean;
}
Options for how the transaction should be committed.
+Type declaration
OptionalallowDirty Read?: boolean If set to
+true, the request will explicitly permit ArangoDB to return a +potentially dirty or stale result and arangojs will load balance the +request without distinguishing between leaders and followers.
Type alias TransactionStatus
id: string;
status: "running" | "committed" | "aborted";
}
Status of a given transaction.
+See also database.TransactionDetails.
+Type declaration
id: string
Unique identifier of the transaction.
+status: "running" | "committed" | "aborted"
Status of the transaction.
+
Type alias ArangoSearchViewDescription
Type declaration
type: "arangosearch"
Type alias ArangoSearchViewLink
analyzers: string[];
cache: boolean;
fields: Record<string, ArangoSearchViewLink>;
includeAllFields: boolean;
nested?: Record<string, ArangoSearchViewLink>;
storeValues: "none" | "id";
trackListPositions: boolean;
}
A link definition for an ArangoSearch View.
+Type declaration
analyzers: string[]
cache: boolean
fields: Record<string, ArangoSearchViewLink>
include
All Fields: boolean Optionalnested?: Record<string, ArangoSearchViewLink>store
Values: "none" | "id" track
List Positions: boolean
Type alias ArangoSearchViewLinkOptions
analyzers?: string[];
cache?: boolean;
fields?: Record<string, ArangoSearchViewLinkOptions>;
inBackground?: boolean;
includeAllFields?: boolean;
nested?: Record<string, ArangoSearchViewLinkOptions>;
storeValues?: "none" | "id";
trackListPositions?: boolean;
}
A link definition for an ArangoSearch View.
+Type declaration
Optionalanalyzers?: string[]A list of names of Analyzers to apply to values of processed document +attributes.
+Default:
+["identity"]Optionalcache?: boolean(Enterprise Edition only.) If set to
+true, then field normalization +values will always be cached in memory.Default:
+falseOptionalfields?: Record<string, ArangoSearchViewLinkOptions>An object mapping names of attributes to process for each document to +ArangoSearchViewLinkOptions definitions.
+OptionalinBackground?: boolean If set to
+true, then no exclusive lock is used on the source collection +during View index creation, so that it remains basically available.Default:
+falseOptionalincludeAll Fields?: boolean If set to
+true, all document attributes will be processed, otherwise +only the attributes infieldswill be processed.Default:
+falseOptionalnested?: Record<string, ArangoSearchViewLinkOptions>(Enterprise Edition only.) An object mapping attribute names to +ArangoSearchViewLinkOptions definitions to index sub-objects +stored in an array.
+OptionalstoreValues?: "none" | "id" Controls how the view should keep track of the attribute values.
+Default:
+"none"OptionaltrackList Positions?: boolean If set to
+true, the position of values in array values will be tracked, +otherwise all values in an array will be treated as equal alternatives.
Type alias ArangoSearchViewPatchPropertiesOptions
Options for partially modifying the properties of an ArangoSearch View.
+Type alias ArangoSearchViewProperties
cleanupIntervalStep: number;
commitIntervalMsec: number;
consolidationIntervalMsec: number;
consolidationPolicy: TierConsolidationPolicy | BytesAccumConsolidationPolicy;
links: Record<string, Omit<ArangoSearchViewLink, "nested">>;
optimizeTopK: string[];
primaryKeyCache: boolean;
primarySort: {
direction: Direction;
field: string;
}[];
primarySortCache: boolean;
primarySortCompression: Compression;
storedValues: {
cache: boolean;
compression: Compression;
fields: string[];
}[];
writebufferActive: number;
writebufferIdle: number;
writebufferSizeMax: number;
}
Properties of an ArangoSearch View.
+Type declaration
cleanup
Interval Step: number commit
Interval Msec: number consolidation
Interval Msec: number consolidation
Policy: TierConsolidationPolicy | BytesAccumConsolidationPolicy links: Record<string, Omit<ArangoSearchViewLink, "nested">>
optimize
TopK: string[] primary
Key Cache: boolean primary
Sort: {
direction: Direction;
field: string;
}[]primary
Sort Cache: boolean primary
Sort Compression: Compression stored
Values: {
cache: boolean;
compression: Compression;
fields: string[];
}[]writebuffer
Active: number writebuffer
Idle: number writebuffer
Size Max: number
Type alias ArangoSearchViewPropertiesOptions
cleanupIntervalStep?: number;
commitIntervalMsec?: number;
consolidationIntervalMsec?: number;
consolidationPolicy?: TierConsolidationPolicy;
links?: Record<string, Omit<ArangoSearchViewLinkOptions, "nested">>;
}
Options for modifying the properties of an ArangoSearch View.
+Type declaration
OptionalcleanupInterval Step?: number How many commits to wait between removing unused files.
+Default:
+2OptionalcommitInterval Msec?: number How long to wait between commiting View data store changes and making +documents visible to queries.
+Default:
+1000OptionalconsolidationInterval Msec?: number How long to wait between applying the
+consolidationPolicy.Default:
+10000OptionalconsolidationPolicy?: TierConsolidationPolicy Consolidation policy to apply for selecting which segments should be +merged.
+Default:
+{ type: "tier" }Optionallinks?: Record<string, Omit<ArangoSearchViewLinkOptions, "nested">>An object mapping names of linked collections to +ArangoSearchViewLinkOptions definitions.
+
Type alias BytesAccumConsolidationPolicy
threshold?: number;
type: "bytes_accum";
}
Policy to consolidate based on segment byte size and live document count as +dictated by the customization attributes.
+Type declaration
Optionalthreshold?: numberMust be in the range of
+0.0to1.0.type: "bytes_accum"
Type of consolidation policy.
+
Deprecated
The bytes_accum consolidation policy was deprecated in
+ArangoDB 3.7 and should be replaced with the tier consolidation policy.
Type alias Compression
Compression for storing data.
+Type alias CreateArangoSearchViewOptions
optimizeTopK?: string[];
primaryKeyCache?: boolean;
primarySort?: ({
direction: Direction;
field: string;
} | {
asc: boolean;
field: string;
})[];
primarySortCache?: boolean;
primarySortCompression?: Compression;
storedValues?: ArangoSearchViewStoredValueOptions[] | string[] | string[][];
type: "arangosearch";
writebufferActive?: number;
writebufferIdle?: number;
writebufferSizeMax?: number;
}
Options for creating an ArangoSearch View.
+Type declaration
OptionaloptimizeTopK?: string[] An array of strings defining sort expressions to optimize.
+OptionalprimaryKey Cache?: boolean (Enterprise Edition only.) If set to
+true, then primary key columns +will always be cached in memory.Default:
+falseOptionalprimarySort?: ({
direction: Direction;
field: string;
} | {
asc: boolean;
field: string;
})[]Attribute path (
+field) for the value of each document that will be +used for sorting.If
+directionis set to"asc"orascis set totrue, +the primary sorting order will be ascending.If
+directionis set to"desc"orascis set tofalse, +the primary sorting order will be descending.OptionalprimarySort Cache?: boolean (Enterprise Edition only.) If set to
+true, then primary sort columns +will always be cached in memory.Default:
+falseOptionalprimarySort Compression?: Compression Compression to use for the primary sort data.
+Default:
+"lz4"OptionalstoredValues?: ArangoSearchViewStoredValueOptions[] | string[] | string[][] Attribute paths for which values should be stored in the view index +in addition to those used for sorting via
+primarySort.type: "arangosearch"
Type of the View.
+OptionalwritebufferActive?: number Maximum number of concurrent active writers that perform a transaction.
+Default:
+0OptionalwritebufferIdle?: number Maximum number of writers cached in the pool.
+Default:
+64OptionalwritebufferSize Max?: number Maximum memory byte size per writer before a writer flush is triggered.
+Default:
+33554432(32 MiB)
Type alias CreateSearchAliasViewOptions
Options for creating a SearchAlias View.
+Type declaration
type: "search-alias"
Type of the View.
+
Type alias CreateViewOptions
Options for creating a View.
+Type alias Direction
Sorting direction. Descending or ascending.
+Type alias GenericViewDescription
globallyUniqueId: string;
id: string;
name: string;
}
Generic description of a View.
+Type declaration
globally
Unique Id: string A globally unique identifier for this View.
+id: string
An identifier for this View.
+name: string
Name of the View.
+
Type alias SearchAliasViewDescription
Type declaration
type: "search-alias"
Type alias SearchAliasViewIndexOptions
collection: string;
index: string;
}
Options defining an index used in a SearchAlias View.
+Type declaration
collection: string
Name of a collection.
+index: string
Name of an inverted index in the collection.
+
Type alias SearchAliasViewPatchIndexOptions
Options defining an index to be modified in a SearchAlias View.
+Type declaration
Optionaloperation?: "add" | "del"Whether to add or remove the index.
+Default:
+"add"
Type alias SearchAliasViewPatchPropertiesOptions
Options for partially modifying the properties of a SearchAlias View.
+Type declaration
indexes: SearchAliasViewPatchIndexOptions[]
An array of inverted indexes to add to the View.
+
Type alias SearchAliasViewProperties
indexes: {
collection: string;
index: string;
}[];
}
Properties of a SearchAlias View.
+Type declaration
indexes: {
collection: string;
index: string;
}[]
Type alias SearchAliasViewPropertiesOptions
Options for modifying the properties of a SearchAlias View.
+Type declaration
indexes: SearchAliasViewIndexOptions[]
An array of inverted indexes to add to the View.
+
Type alias TierConsolidationPolicy
minScore?: number;
segmentsBytesFloor?: number;
segmentsBytesMax?: number;
segmentsMax?: number;
segmentsMin?: number;
type: "tier";
}
Policy to consolidate if the sum of all candidate segment byte size is less +than the total segment byte size multiplied by a given threshold.
+Type declaration
OptionalminScore?: number Consolidation candidates with a score less than this value will be +filtered out.
+Default:
+0OptionalsegmentsBytes Floor?: number Size below which all segments are treated as equivalent.
+Default:
+2097152(2 MiB)OptionalsegmentsBytes Max?: number Maximum allowed size of all consolidation segments.
+Default:
+5368709120(5 GiB)OptionalsegmentsMax?: number Maximum number of segments that are evaluated as candidates for +consolidation.
+Default:
+10OptionalsegmentsMin?: number Minimum number of segments that are evaluated as candidates for +consolidation.
+Default:
+1type: "tier"
Type of consolidation policy.
+
Type alias ViewDescription
Type alias ViewPatchPropertiesOptions
Options for partially modifying a View's properties.
+Type alias ViewProperties
Type alias ViewPropertiesOptions
Options for replacing a View's properties.
+
Represents an Analyzer in a database.Database.
+