Class Analyzer
Accessors
database
name
- get name(): string
Name of this Analyzer.
+See also databases.Database.
+Returns string
Methods
create
- create<Options>(options): Promise<Options extends {
        features?: AnalyzerFeature[];
        properties?: Record<string, never>;
        type: "identity";
    }
    ? IdentityAnalyzerDescription
    : Options extends CreateDelimiterAnalyzerOptions
        ? DelimiterAnalyzerDescription
        : Options extends {
                features?: AnalyzerFeature[];
                properties: {
                    locale: string;
                };
                type: "stem";
            }
            ? StemAnalyzerDescription
            : Options extends {
                    features?: AnalyzerFeature[];
                    properties: {
                        accent?: boolean;
                        case?: CaseConversion;
                        locale: string;
                    };
                    type: "norm";
                }
                ? NormAnalyzerDescription
                : Options extends {
                        features?: AnalyzerFeature[];
                        properties: {
                            max: number;
                            min: number;
                            preserveOriginal: boolean;
                        };
                        type: "ngram";
                    }
                    ? NgramAnalyzerDescription
                    : Options extends {
                            features?: AnalyzerFeature[];
                            properties: {
                                accent?: boolean;
                                case?: CaseConversion;
                                edgeNgram?: {
                                    max?: ...;
                                    min?: ...;
                                    preserveOriginal?: ...;
                                };
                                locale: string;
                                stemming?: boolean;
                                stopwords?: (...)[];
                                stopwordsPath?: string;
                            };
                            type: "text";
                        }
                        ? TextAnalyzerDescription
                        : Options extends {
                                features?: (...)[];
                                properties: {
                                    break?: (...) | (...);
                                    case?: (...) | (...);
                                };
                                type: "segmentation";
                            }
                            ? SegmentationAnalyzerDescription
                            : Options extends {
                                    features?: (...) | (...);
                                    properties: {
                                        batchSize?: ...;
                                        collapsePositions?: ...;
                                        keepNull?: ...;
                                        memoryLimit?: ...;
                                        queryString: ...;
                                        returnType?: ...;
                                    };
                                    type: "aql";
                                }
                                ? AqlAnalyzerDescription
                                : Options extends {
                                        features?: ...;
                                        properties: ...;
                                        type: ...;
                                    }
                                    ? PipelineAnalyzerDescription
                                    : (...) extends (...)
                                        ? (...)
                                        : (...)> Creates a new Analyzer with the given
+optionsand the instance's name.See also databases.Database#createAnalyzer.
+Type Parameters
- Options extends CreateAnalyzerOptions
Parameters
- options: Options
Options for creating the Analyzer.
+
Returns Promise<Options extends {
        features?: AnalyzerFeature[];
        properties?: Record<string, never>;
        type: "identity";
    }
    ? IdentityAnalyzerDescription
    : Options extends CreateDelimiterAnalyzerOptions
        ? DelimiterAnalyzerDescription
        : Options extends {
                features?: AnalyzerFeature[];
                properties: {
                    locale: string;
                };
                type: "stem";
            }
            ? StemAnalyzerDescription
            : Options extends {
                    features?: AnalyzerFeature[];
                    properties: {
                        accent?: boolean;
                        case?: CaseConversion;
                        locale: string;
                    };
                    type: "norm";
                }
                ? NormAnalyzerDescription
                : Options extends {
                        features?: AnalyzerFeature[];
                        properties: {
                            max: number;
                            min: number;
                            preserveOriginal: boolean;
                        };
                        type: "ngram";
                    }
                    ? NgramAnalyzerDescription
                    : Options extends {
                            features?: AnalyzerFeature[];
                            properties: {
                                accent?: boolean;
                                case?: CaseConversion;
                                edgeNgram?: {
                                    max?: ...;
                                    min?: ...;
                                    preserveOriginal?: ...;
                                };
                                locale: string;
                                stemming?: boolean;
                                stopwords?: (...)[];
                                stopwordsPath?: string;
                            };
                            type: "text";
                        }
                        ? TextAnalyzerDescription
                        : Options extends {
                                features?: (...)[];
                                properties: {
                                    break?: (...) | (...);
                                    case?: (...) | (...);
                                };
                                type: "segmentation";
                            }
                            ? SegmentationAnalyzerDescription
                            : Options extends {
                                    features?: (...) | (...);
                                    properties: {
                                        batchSize?: ...;
                                        collapsePositions?: ...;
                                        keepNull?: ...;
                                        memoryLimit?: ...;
                                        queryString: ...;
                                        returnType?: ...;
                                    };
                                    type: "aql";
                                }
                                ? AqlAnalyzerDescription
                                : Options extends {
                                        features?: ...;
                                        properties: ...;
                                        type: ...;
                                    }
                                    ? 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 BatchCursor<ItemType>
The BatchCursor provides a batch-wise API to an Cursor.
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 Cursor<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
database
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
id
- get id(): undefined | string
ID of this cursor.
+Returns undefined | string
items
items
- get itemsView(): BatchCursorItemsView<ItemType>
A low-level interface for consuming the items of this BatchCursor.
+Returns BatchCursorItemsView<ItemType>
Methods
[async
- [async
Iterator](): AsyncGenerator<ItemType[], 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<ItemType[], 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<ItemType[][]>
Depletes the cursor, then returns an array containing all batches in the +cursor's remaining result list.
+Returns Promise<ItemType[][]>
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: ItemType[]
- 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 +BatchCursor#forEach, BatchCursor#reduce or +BatchCursor#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 | ItemType[]>
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 | ItemType[]>
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 BatchCursor#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 Cursor<ItemType>
The Cursor type represents a cursor returned from a
+databases.Database#query.
When using TypeScript, cursors can be cast to a specific item type in order +to increase type safety.
+See also BatchCursor.
+Example
const db = new Database();
const query = aql`FOR x IN 1..5 RETURN x`;
const result = await db.query(query) as Cursor<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(): BatchCursor<ItemType>
A BatchCursor providing batch-wise access to the cursor +result set.
+See also BatchCursor#items.
+Returns BatchCursor<ItemType>
count
- get count(): undefined | number
Total number of documents in the query result. Only available if the +
+countoption was used.Returns undefined | number
database
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
id
- get id(): undefined | string
ID of this cursor.
+Returns undefined | string
Methods
[async
- [async
Iterator](): AsyncGenerator<ItemType, 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<ItemType, 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<ItemType[]>
Depletes the cursor, then returns an array containing all values in the +cursor's remaining result list.
+Returns Promise<ItemType[]>
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: ItemType
- 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 +Cursor#forEach, Cursor#reduce or +Cursor#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 | ItemType>
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 | ItemType>
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 Cursor#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 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 analyzers.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 +analyzers.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 +
availability
- availability(graceful?): Promise<ServerAvailability>
Fetches availability information about the server.
+Parameters
- graceful: boolean = false
If set to
+true, the method will always returnfalse+instead of throwing an error; otherwisefalsewill only be returned +when the server responds with a 503 status code or an ArangoDB error with +a code of 503, such as during shutdown.
Returns Promise<ServerAvailability>
Example
+const availability = await db.availability();
// availability is either "default", "readonly", or false +- graceful: boolean = false
begin
- begin
Transaction(collections, options?): Promise<Transaction> Begins a new streaming transaction for the given collections, then returns +a transactions.Transaction instance for the transaction.
+Collections can be specified as collection names (strings) or objects +implementing the collections.ArangoCollection interface:
+Collection, +graphs.GraphVertexCollection, graphs.GraphEdgeCollection as +well as (in TypeScript) collections.DocumentCollection and +collections.EdgeCollection.Parameters
- collections: TransactionCollectionOptions
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: TransactionCollectionOptions
- begin
Transaction(collections, options?): Promise<Transaction> Begins a new streaming transaction for the given collections, then returns +a transactions.Transaction instance for the transaction.
+Collections can be specified as collection names (strings) or objects +implementing the collections.ArangoCollection interface:
+Collection, +graphs.GraphVertexCollection, graphs.GraphEdgeCollection as well as +(in TypeScript) collections.DocumentCollection and collections.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 transactions.Transaction instance for the transaction.
+The Collection can be specified as a collection name (string) or an object +implementing the collections.ArangoCollection interface:
+Collection, +graphs.GraphVertexCollection, graphs.GraphEdgeCollection as well as +(in TypeScript) collections.DocumentCollection and collections.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<EntryResultType, EntryInputType>(collectionName): DocumentCollection<EntryResultType, EntryInputType> & EdgeCollection<EntryResultType, EntryInputType>
Returns a
+Collectioninstance for the given collection name.In TypeScript the collection implements both the +collections.DocumentCollection and collections.EdgeCollection +interfaces and can be cast to either type to enforce a stricter API.
+Type Parameters
- EntryResultType extends Record<string, any> = any
Type to represent document contents returned by +the server (including computed properties).
+ - EntryInputType extends Record<string, any> = EntryResultType
Type to represent document contents passed when +inserting or replacing documents (without computed properties).
+
Parameters
- collectionName: string
Name of the edge collection.
+
Returns DocumentCollection<EntryResultType, EntryInputType> & EdgeCollection<EntryResultType, EntryInputType>
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>; +- EntryResultType extends Record<string, any> = any
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 +collections.DocumentCollection and collections.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(options): Promise<ClusterRebalanceResult> Computes a set of move shard operations to rebalance the cluster.
+Parameters
- options: 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 analyzers.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<EntryResultType, EntryInputType>(collectionName, options?): Promise<DocumentCollection<EntryResultType, EntryInputType>> Creates a new collection with the given
+collectionNameandoptions, +then returns a collections.DocumentCollection instance for the new collection.Type Parameters
- EntryResultType extends Record<string, any> = any
Type to represent document contents returned by +the server (including computed properties).
+ - EntryInputType extends Record<string, any> = EntryResultType
Type to represent document contents passed when +inserting or replacing documents (without computed properties).
+
Parameters
- collectionName: string
Name of the new collection.
+ Optionaloptions: CollectionPropertiesOptions & {
    distributeShardsLike?: string;
    enforceReplicationFactor?: boolean;
    keyOptions?: CollectionKeyOptions;
    numberOfShards?: number;
    shardKeys?: string[];
    shardingStrategy?: ShardingStrategy;
    smartGraphAttribute?: string;
    smartJoinAttribute?: string;
    waitForSyncReplication?: boolean;
} & {
    type?: DOCUMENT_COLLECTION;
}Options for creating the collection.
+
Returns Promise<DocumentCollection<EntryResultType, EntryInputType>>
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"); +- EntryResultType extends Record<string, any> = any
- create
Collection<EntryResultType, EntryInputType>(collectionName, options): Promise<EdgeCollection<EntryResultType, EntryInputType>> Creates a new edge collection with the given
+collectionNameand +options, then returns an collections.EdgeCollection instance for the new +edge collection.Type Parameters
- EntryResultType extends Record<string, any> = any
Type to represent edge document contents returned +by the server (including computed properties).
+ - EntryInputType extends Record<string, any> = EntryResultType
Type to represent edge document contents passed +when inserting or replacing documents (without computed properties).
+
Parameters
- collectionName: string
Name of the new collection.
+ - options: CollectionPropertiesOptions & {
    distributeShardsLike?: string;
    enforceReplicationFactor?: boolean;
    keyOptions?: CollectionKeyOptions;
    numberOfShards?: number;
    shardKeys?: string[];
    shardingStrategy?: ShardingStrategy;
    smartGraphAttribute?: string;
    smartJoinAttribute?: string;
    waitForSyncReplication?: boolean;
} & {
    type: EDGE_COLLECTION;
}Options for creating the collection.
+
Returns Promise<EdgeCollection<EntryResultType, EntryInputType>>
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
}); +- EntryResultType extends Record<string, any> = any
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: CreateDatabaseUserOptions[]
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<EntryResultType, EntryInputType>(collectionName, options?): Promise<EdgeCollection<EntryResultType, EntryInputType>> Creates a new edge collection with the given
+collectionNameand +options, then returns an collections.EdgeCollection instance for the new +edge collection.This is a convenience method for calling Database#createCollection +with
+options.typeset toEDGE_COLLECTION.Type Parameters
- EntryResultType extends Record<string, any> = any
Type to represent edge document contents returned +by the server (including computed properties).
+ - EntryInputType extends Record<string, any> = EntryResultType
Type to represent edge document contents passed +when inserting or replacing documents (without computed properties).
+
Parameters
- collectionName: string
Name of the new collection.
+ Optionaloptions: CreateCollectionOptionsOptions for creating the collection.
+
Returns Promise<EdgeCollection<EntryResultType, EntryInputType>>
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"); +- EntryResultType extends Record<string, any> = any
create
- create
Graph(graphName, edgeDefinitions, options?): Promise<Graph> Creates a graph with the given
+graphNameandedgeDefinitions, then +returns a graphs.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 jobs.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
User 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.createUserFunction(
"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
View(viewName, options): Promise<View> Creates a new View with the given
+viewNameandoptions, then returns a +views.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 = systemDb.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
User 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.dropUserFunction("ACME::ACCOUNTING::CALCULATE_VAT");
// the function no longer exists +- name: string
engine
- engine(): Promise<EngineInfo>
Fetches storage engine information from the ArangoDB server.
+Returns Promise<EngineInfo>
Example
+const db = new Database();
const engine = await db.engine();
// the engine object contains the storage engine information, e.g.
// name: name of the storage engine +
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 collections.ArangoCollection interface:
+Collection, +graphs.GraphVertexCollection, graphs.GraphEdgeCollection as well as +(in TypeScript) collections.DocumentCollection and collections.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: TransactionCollectionOptions & {
    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: TransactionCollectionOptions & {
- 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 collections.ArangoCollection interface:
+Collection, +graphs.GraphVertexCollection, graphs.GraphEdgeCollection as well as +(in TypeScript) collections.DocumentCollection and collections.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 collections.ArangoCollection interface:
+Collection, +graphs.GraphVertexCollection, graphs.GraphEdgeCollection as well as +(in TypeScript) collections.DocumentCollection and collections.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<DatabaseDescription>
Fetches the database description for the active database from the server.
+Returns Promise<DatabaseDescription>
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
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.getHotBackups();
for (const backup of backups.list) {
console.log(backup.id);
} +
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
Service(mount): Promise<ServiceDescription> Retrieves information about a mounted service.
+Parameters
- mount: string
The service's mount point, relative to the database.
+
Returns Promise<ServiceDescription>
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
Service Scripts(mount): Promise<Record<string, string>> Retrieves an object mapping script names to their human readable +representations, as defined in the service manifest's "scripts" section.
+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.getServiceScripts("/my-service");
for (const [name, title] of Object.entries(scripts)) {
console.log(`${name}: ${title}`);
} +- 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 graphs.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 graphs.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<ServiceDescription> 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<ServiceDescription>
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<CollectionDescription[]> 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<CollectionDescription[]>
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
Graphs(): Promise<GraphDescription[]> Fetches all graphs from the database and returns an array of graph +descriptions.
+See also Database#graphs.
+Returns Promise<GraphDescription[]>
Example
+const db = new Database();
const graphs = await db.listGraphs();
// graphs is an array of graph descriptions +
list
- list
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.listLogMessages();
for (const m of messages) {
console.log(`${m.date} - [${m.level}] ${m.message} (#${m.id})`);
} +
list
list
- list
Running Queries(): Promise<QueryDescription[]> Fetches a list of information for all currently running queries.
+See also Database#listSlowQueries and Database#killQuery.
+Returns Promise<QueryDescription[]>
Example
+const db = new Database();
const queries = await db.listRunningQueries(); +
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<QueryDescription[]> Fetches a list of information for all recent slow queries.
+See also Database#listRunningQueries and +Database#clearSlowQueries.
+Returns Promise<QueryDescription[]>
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
User Functions(): Promise<UserFunctionDescription[]> Fetches a list of all AQL user functions registered with the database.
+Returns Promise<UserFunctionDescription[]>
Example
+const db = new Database();
const functions = await db.listUserFunctions();
const names = functions.map(fn => fn.name); +
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
`); +aql.
+- query: string | AqlLiteral | AqlQuery<any>
query
- query<T>(query, options?): Promise<Cursor<T>>
Performs a database query using the given
+query, then returns a new +cursors.Cursor 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<Cursor<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<Cursor<T>>
Performs a database query using the given
+queryandbindVars, then +returns a new cursors.Cursor 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<Cursor<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<QueryTrackingInfo> Fetches the query tracking properties.
+Returns Promise<QueryTrackingInfo>
Example
+const db = new Database();
const tracking = await db.queryTracking();
console.log(tracking.enabled); +- query
Tracking(options): Promise<QueryTrackingInfo> Modifies the query tracking properties.
+Parameters
- options: QueryTrackingOptions
Options for query tracking.
+
Returns Promise<QueryTrackingInfo>
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
rename
- rename
Collection(collectionName, newName): Promise<ArangoApiResponse<CollectionDescription>> 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<CollectionDescription>>
- collectionName: string
rename
- rename
View(viewName, newName): Promise<ArangoApiResponse<ViewDescription>> Renames the view
+viewNametonewName.Additionally removes any stored views.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<ServiceDescription> 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<ServiceDescription>
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 routes.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: Record<string, string> | HeadersDefault 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<ServiceDescription> 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<ServiceDescription>
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
status
- status(): Promise<ServerStatusInformation>
Fetches information about the server status.
+Returns Promise<ServerStatusInformation>
Example
+const status = await db.status();
// the status object contains the ArangoDB status information, e.g.
// version: ArangoDB version number
// host: host identifier of the server
// serverInfo: detailed information about the server +
support
- support
Info(): Promise<SingleServerSupportInfo | ClusterSupportInfo> Fetches deployment information about the server for support purposes.
+Note that this API may reveal sensitive data about the deployment.
+Returns Promise<SingleServerSupportInfo | ClusterSupportInfo>
time
transaction
- transaction(transactionId): Transaction
Returns a transactions.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 +transactions.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<ServiceDescription> 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<ServiceDescription>
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
- view(viewName): View
Returns a views.View instance for the given
+viewName.Parameters
- viewName: string
Name of the ArangoSearch or SearchAlias View.
+
Returns View
Example
+const db = new Database();
const view = db.view("potatoes"); +- viewName: string
views
- views(): Promise<View[]>
Fetches all Views from the database and returns an array of +views.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 collections.ArangoCollection interface:
+Collection, +graphs.GraphVertexCollection, graphs.GraphEdgeCollection as +well as (in TypeScript) collections.DocumentCollection and +collections.EdgeCollection.Type Parameters
Parameters
- collections: TransactionCollectionOptions
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: TransactionCollectionOptions
- 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 collections.ArangoCollection interface:
+Collection, +graphs.GraphVertexCollection, graphs.GraphEdgeCollection as well as +(in TypeScript) collections.DocumentCollection and collections.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 collections.ArangoCollection interface:
+Collection, +graphs.GraphVertexCollection, graphs.GraphEdgeCollection as well as +(in TypeScript) collections.DocumentCollection and collections.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
Constructors
Properties
Accessors
Methods
Constructors
constructor
- new
Arango Error(data, options): ArangoError Creates a new
+ArangoErrorfrom an ArangoDB error response.Parameters
- data: ArangoErrorResponse
- options: {
    cause?: Error;
    isSafeToRetry?: null | boolean;
}Optionalcause?: ErrorOptionalisSafe To Retry?: null | boolean
Returns ArangoError
Properties
code
HTTP status code included in the server error response object.
+error
ArangoDB error code.
+ +name
Static Optional prepare
Optional override for formatting stack traces
+Type declaration
- (err, stackTraces): any
Parameters
- err: Error
- stackTraces: CallSite[]
Returns any
Static stack
Accessors
error
- get errorMessage(): string
Error message accompanying the error code.
+Returns string
request
- get request(): undefined | Request
Fetch request object.
+Returns undefined | Request
response
- get response(): undefined | ProcessedResponse<ArangoErrorResponse>
Server response object.
+Returns undefined | ProcessedResponse<ArangoErrorResponse>
Methods
toJSON
Static capture
Class FetchFailedError
Represents an error from a failed fetch request.
+The root cause is often extremely difficult to determine.
+Hierarchy (view full)
- NetworkError
- FetchFailedError
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Fetch Failed Error(message, options): FetchFailedError Parameters
- message: undefined | string
- options: {
    cause: TypeError;
    isSafeToRetry?: null | boolean;
    request: Request;
}cause: TypeError
OptionalisSafe To Retry?: null | boolean request: Request
Returns FetchFailedError
Properties
is
Indicates whether the request that caused this error can be safely retried.
+name
request
Fetch request 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 (view full)
- NetworkError
- HttpError
Index
Properties
Methods
Properties
code
HTTP status code of the server response.
+is
Indicates whether the request that caused this error can be safely retried.
+name
request
Fetch request object.
+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 NetworkError
Represents a network error or an error encountered while performing a network request.
+Hierarchy (view full)
- Error
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Network Error(message, options): NetworkError Parameters
- message: string
- options: {
    cause?: Error;
    isSafeToRetry?: null | boolean;
    request: Request;
}Optionalcause?: ErrorOptionalisSafe To Retry?: null | boolean request: Request
Returns NetworkError
Properties
is
Indicates whether the request that caused this error can be safely retried.
+name
request
Fetch request 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 PropagationTimeoutError
Represents an error from a deliberate timeout encountered while waiting +for propagation.
+Hierarchy
- Error
- PropagationTimeoutError
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Propagation Timeout Error(message, options): PropagationTimeoutError Parameters
- message: undefined | string
- options: {
    cause: Error;
}cause: Error
Returns PropagationTimeoutError
Properties
name
Static Optional prepare
Optional override for formatting stack traces
+Type declaration
- (err, stackTraces): any
Parameters
- err: Error
- stackTraces: CallSite[]
Returns any
Static stack
Methods
Static capture
Class RequestAbortedError
Represents an error from a request that was aborted.
+Hierarchy (view full)
- NetworkError
- RequestAbortedError
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Request Aborted Error(message, options): RequestAbortedError Parameters
- message: undefined | string
- options: {
    cause?: Error;
    isSafeToRetry?: null | boolean;
    request: Request;
}Optionalcause?: ErrorOptionalisSafe To Retry?: null | boolean request: Request
Returns RequestAbortedError
Properties
is
Indicates whether the request that caused this error can be safely retried.
+name
request
Fetch request 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 ResponseTimeoutError
Represents an error from a deliberate timeout encountered while waiting +for a server response.
+Hierarchy (view full)
- NetworkError
- ResponseTimeoutError
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Response Timeout Error(message, options): ResponseTimeoutError Parameters
- message: undefined | string
- options: {
    cause?: Error;
    isSafeToRetry?: null | boolean;
    request: Request;
}Optionalcause?: ErrorOptionalisSafe To Retry?: null | boolean request: Request
Returns ResponseTimeoutError
Properties
is
Indicates whether the request that caused this error can be safely retried.
+name
request
Fetch request 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 databases.Database.
+ Index
Accessors
database
is
- get isArangoGraph(): true
Indicates that this object represents an ArangoDB Graph.
+Returns true
name
- get name(): string
Name of the graph.
+Returns string
Methods
add
- add
Edge Definition(edgeDefinition, options?): Promise<GraphDescription> Adds an edge definition to this graph.
+Parameters
- edgeDefinition: EdgeDefinitionOptions
Definition of a relation in this graph.
+ - options: AddEdgeDefinitionOptions = {}
Returns Promise<GraphDescription>
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<GraphDescription> 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<GraphDescription>
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<GraphDescription>
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<GraphDescription>
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, T> Returns a 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, 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, any>[]> Fetches all edge collections of this graph from the database and returns +an array of GraphEdgeCollection instances.
+See also Graph#listEdgeCollections.
+Returns Promise<GraphEdgeCollection<any, 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
- get(): Promise<GraphDescription>
Retrieves general information about the graph.
+Returns Promise<GraphDescription>
Example
+const db = new Database();
const graph = db.graph("some-graph");
const data = await graph.get();
// data contains general information about the graph +
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#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#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<GraphDescription> 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<GraphDescription>
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<GraphDescription> 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<GraphDescription>
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<GraphDescription> 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<GraphDescription>
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<GraphDescription> 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<GraphDescription>
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, T> Returns a 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, T>
- collection: string | ArangoCollection
vertex
- vertex
Collections(): Promise<GraphVertexCollection<any, any>[]> Fetches all vertex collections of this graph from the database and returns +an array of GraphVertexCollection instances.
+See also Graph#listVertexCollections.
+Returns Promise<GraphVertexCollection<any, 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<EntryResultType, EntryInputType>
Represents a collections.EdgeCollection of edges in a Graph.
+Type Parameters
- EntryResultType extends Record<string, any> = any
Type to represent edge document contents returned +by the server (including computed properties).
+ - EntryInputType extends Record<string, any> = EntryResultType
Type to represent edge document contents passed +when inserting or replacing edge documents (without computed properties).
+
Implements
Index
Accessors
Methods
Accessors
collection
- get collection(): EdgeCollection<EntryResultType, EntryInputType>
A collections.EdgeCollection instance for this edge collection.
+Returns EdgeCollection<EntryResultType, EntryInputType>
database
graph
name
- get name(): string
Name of the collection.
+Returns string
Methods
edge
- edge(selector, options?): Promise<Edge<EntryResultType>>
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: ReadGraphDocumentOptionsOptions for retrieving the edge.
+
Returns Promise<Edge<EntryResultType>>
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<EntryResultType>>
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<EntryResultType>>
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<EntryResultType>;
}> 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: RemoveGraphDocumentOptionsOptions for removing the edge.
+
Returns Promise<DocumentMetadata & {
    old?: Edge<EntryResultType>;
}>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<EntryResultType>;
    old?: Edge<EntryResultType>;
}> 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<EntryInputType>
Optionaloptions: ReplaceGraphDocumentOptionsOptions for replacing the edge.
+
Returns Promise<DocumentMetadata & {
    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
save
- save(data, options?): Promise<DocumentMetadata & {
    new?: Edge<EntryResultType>;
}> Inserts a new edge with the given
+datainto the collection.Parameters
- data: EdgeData<EntryInputType>
The contents of the new edge.
+ Optionaloptions: InsertGraphDocumentOptionsOptions for inserting the edge.
+
Returns Promise<DocumentMetadata & {
    new?: 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>
update
- update(selector, newValue, options?): Promise<DocumentMetadata & {
    new?: Edge<EntryResultType>;
    old?: Edge<EntryResultType>;
}> 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<EntryInputType>>
Optionaloptions: ReplaceGraphDocumentOptionsOptions for updating the edge.
+
Returns Promise<DocumentMetadata & {
    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
Class GraphVertexCollection<EntryResultType, EntryInputType>
Represents a collections.DocumentCollection of vertices in a Graph.
+Type Parameters
- EntryResultType extends Record<string, any> = any
Type to represent vertex document contents returned +by the server (including computed properties).
+ - EntryInputType extends Record<string, any> = EntryResultType
Type to represent vertex document contents passed +when inserting or replacing vertex documents (without computed properties).
+
Implements
Index
Accessors
Methods
Accessors
collection
- get collection(): DocumentCollection<EntryResultType, EntryInputType>
A collections.DocumentCollection instance for this vertex collection.
+Returns DocumentCollection<EntryResultType, EntryInputType>
database
graph
name
- get name(): string
Name of the collection.
+Returns string
Methods
remove
- remove(selector, options?): Promise<DocumentMetadata & {
    old?: Document<EntryResultType>;
}> 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: RemoveGraphDocumentOptionsOptions for removing the vertex.
+
Returns Promise<DocumentMetadata & {
    old?: Document<EntryResultType>;
}>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<EntryResultType>;
    old?: Document<EntryResultType>;
}> 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<EntryInputType>
Optionaloptions: ReplaceGraphDocumentOptionsOptions for replacing the vertex.
+
Returns Promise<DocumentMetadata & {
    new?: Document<EntryResultType>;
    old?: Document<EntryResultType>;
}>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<EntryResultType>;
}> Inserts a new vertex with the given
+datainto the collection.Parameters
- data: DocumentData<EntryInputType>
The contents of the new vertex.
+ Optionaloptions: InsertGraphDocumentOptionsOptions for inserting the vertex.
+
Returns Promise<DocumentMetadata & {
    new?: Document<EntryResultType>;
}>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<EntryInputType>
update
- update(selector, newValue, options?): Promise<DocumentMetadata & {
    new?: Document<EntryResultType>;
    old?: Document<EntryResultType>;
}> 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<EntryInputType>>
Optionaloptions: ReplaceGraphDocumentOptionsOptions for updating the vertex.
+
Returns Promise<DocumentMetadata & {
    new?: Document<EntryResultType>;
    old?: Document<EntryResultType>;
}>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<EntryResultType>>
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: ReadGraphDocumentOptionsOptions for retrieving the vertex.
+
Returns Promise<Document<EntryResultType>>
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<EntryResultType>>
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<EntryResultType>>
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<ResultType>
Represents an async job in a databases.Database.
+Type Parameters
Index
Accessors
Methods
Accessors
database
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
- get result(): undefined | ResultType
The job's result if it has been loaded or
+undefinedotherwise.Returns undefined | ResultType
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 | ResultType>
Loads the job's result from the database if it is not already loaded.
+Returns Promise<undefined | ResultType>
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.
+Accessors
database
headers
- get headers(): Headers
Headers of this route.
+Returns Headers
path
- get path(): string
Path of this route.
+Returns string
Methods
delete
- delete(path, search?, headers?): Promise<ProcessedResponse<any>>
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: Record<string, string> | HeadersAdditional headers to send with this request.
+
Returns Promise<ProcessedResponse<any>>
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<ProcessedResponse<any>>
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: Record<string, string> | HeadersAdditional headers to send with this request.
+
Returns Promise<ProcessedResponse<any>>
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<ProcessedResponse<any>>
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: Record<string, string> | HeadersAdditional headers to send with this request.
+
Returns Promise<ProcessedResponse<any>>
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<ProcessedResponse<any>>
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: Record<string, string> | HeadersAdditional headers to send with this request.
+
Returns Promise<ProcessedResponse<any>>
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<ProcessedResponse<any>>
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: Record<string, string> | HeadersAdditional headers to send with this request.
+
Returns Promise<ProcessedResponse<any>>
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<ProcessedResponse<any>>
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: Record<string, string> | HeadersAdditional headers to send with this request.
+
Returns Promise<ProcessedResponse<any>>
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<ProcessedResponse<any>>
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: Record<string, string> | HeadersAdditional headers to send with this request.
+
Returns Promise<ProcessedResponse<any>>
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<ProcessedResponse<any>>
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: Record<string, string> | HeadersAdditional headers to send with this request.
+
Returns Promise<ProcessedResponse<any>>
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<ProcessedResponse<any>>
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: Record<string, string> | HeadersAdditional headers to send with this request.
+
Returns Promise<ProcessedResponse<any>>
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<ProcessedResponse<any>>
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: Record<string, string> | HeadersAdditional headers to send with this request.
+
Returns Promise<ProcessedResponse<any>>
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<ProcessedResponse<any>>
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: Record<string, string> | HeadersAdditional headers to send with this request.
+
Returns Promise<ProcessedResponse<any>>
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<ProcessedResponse<any>>
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: Record<string, string> | HeadersAdditional headers to send with this request.
+
Returns Promise<ProcessedResponse<any>>
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<ProcessedResponse<any>>
Performs an arbitrary HTTP request relative to this route and returns the +server response.
+Parameters
Optionaloptions: RequestOptionsOptions for performing the request.
+
Returns Promise<ProcessedResponse<any>>
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: Record<string, string> | HeadersAdditional 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 databases.Database.
+Accessors
database
id
- get id(): string
Unique identifier of this transaction.
+ +Returns string
Methods
abort
- abort(options?): Promise<TransactionInfo>
Attempts to abort the transaction to the databases.
+Parameters
- options: TransactionAbortOptions = {}
Options for aborting the transaction.
+
Returns Promise<TransactionInfo>
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<TransactionInfo>
Attempts to commit the transaction to the databases.
+Parameters
- options: TransactionCommitOptions = {}
Options for comitting the transaction.
+
Returns Promise<TransactionInfo>
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<TransactionInfo>
Retrieves general information about the transaction.
+Returns Promise<TransactionInfo>
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 databases.Database.
+ Index
Accessors
Methods
Accessors
database
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 databases.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 databases.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 UpdateSearchAliasViewPropertiesOptions
        ? SearchAliasViewProperties
        : ViewProperties> Updates the properties of the View.
+Type Parameters
- Properties extends undefined | UpdateViewPropertiesOptions
Parameters
Optionalproperties: PropertiesProperties of the View to update.
+
Returns Promise<Properties extends ArangoSearchViewPropertiesOptions
    ? ArangoSearchViewProperties
    : Properties extends UpdateSearchAliasViewPropertiesOptions
        ? 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 collections.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 isNetworkError
- is
Network Error(error): error is NetworkError Indicates whether the given value represents a NetworkError.
+Parameters
- error: any
A value that might be a
+NetworkError.
Returns error is NetworkError
- error: any
Function arangojs
- arangojs(config?): Database
Creates a new
+Databaseinstance with its own connection pool.This is a wrapper function for the :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 :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 - v10.0.0-alpha.0
Class Hierarchy
arangojs - v10.0.0-alpha.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/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 the server returns an ArangoDB error response, arangojs will throw an
+ArangoError with an errorNum property indicating the ArangoDB error code
+and expose the response body as the response property of the error object.
For all other errors during the request/response cycle, arangojs will throw a
+NetworkError or a more specific subclass thereof and expose the originating
+request object as the request property of the error object.
If the server responded with a non-2xx status code, this NetworkError will
+be an HttpError with a code property indicating the HTTP status code of the
+response and a response property containing the response object itself.
If the error is caused by an exception, the originating exception will be
+available as the cause property of the error object thrown by arangojs. For
+network errors, this will often be a TypeError.
Node.js network errors
In Node.js, network errors caused by a TypeError will often have a cause
+property containing a more detailed exception.
Specifically, these are often either system errors (represented by regular
+Error objects with additional properties) or errors from the undici module
+Node.js uses internally for its native fetch implementation.
Node.js system error objects provide a code property containing the specific
+string error code, a syscall property identifying the underlying system call
+that triggered the error (e.g. connect), as well as other helpful properties.
For more details on Node.js system errors, see the Node.js documentation of the
+SystemError interface
+as well as the section on
+Node.js error codes.
For more details on the errors thrown by undici, see the
+undici errors documentation.
Common issues
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. 8.x.y -> 9.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.
+You can install an older version of arangojs using npm or yarn:
# for version 8.x.x
yarn add arangojs@8
# - or -
npm install --save arangojs@8
+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 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,
})
);
+This is a known limitation +of Node.js at the time of this writing.
+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 the transaction.step 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 QueueTimeMetrics
An object providing methods for accessing queue time metrics of the most +recently received server responses if the server supports this feature.
+Â Â Â Â getAvg(): number;
    getLatest(): undefined | number;
    getValues(): [number, number][];
}
Methods
get
get
get
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]?: any;
    bindVars: Record<string, any>;
    query: string;
}
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 databases.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.
+Example
interface Person {
name: string;
}
const db = new Database();
const documents = db.collection("persons") as DocumentCollection<Person>;
+Â Â Â Â database: Database;
    name: string;
    checksum(options?): Promise<ArangoApiResponse<CollectionDescription & {
        checksum: string;
        revision: string;
    }>>;
    compact(): Promise<ArangoApiResponse<CollectionDescription>>;
    count(): Promise<ArangoApiResponse<CollectionDescription & CollectionProperties & {
        count: number;
    }>>;
    create(options?): Promise<ArangoApiResponse<CollectionDescription & 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<{
        id: string;
    }>>;
    dropIndex(selector): Promise<ArangoApiResponse<{
        id: string;
    }>>;
    ensureIndex(options): Promise<ArangoApiResponse<{
        fields: string[];
        figures?: Record<string, any>;
        id: string;
        name: string;
        sparse: boolean;
        type: "persistent";
        unique: boolean;
    } & {
        cacheEnabled: boolean;
        deduplicate: boolean;
        estimates: boolean;
        storedValues?: string[];
    } & {
        isNewlyCreated: boolean;
    }>>;
    ensureIndex(options): Promise<ArangoApiResponse<{
        fields: [string];
        figures?: Record<string, any>;
        id: string;
        name: string;
        sparse: boolean;
        type: "ttl";
        unique: boolean;
    } & {
        expireAfter: number;
        selectivityEstimate: number;
    } & {
        isNewlyCreated: boolean;
    }>>;
    ensureIndex(options): Promise<ArangoApiResponse<{
        fields: string[];
        figures?: Record<string, any>;
        id: string;
        name: string;
        sparse: boolean;
        type: "mdi";
        unique: boolean;
    } & {
        fieldValueTypes: "double";
    } & {
        isNewlyCreated: boolean;
    }>>;
    ensureIndex(options): Promise<ArangoApiResponse<{
        fields: [string, string] | [string];
        figures?: Record<string, any>;
        id: string;
        name: string;
        sparse: boolean;
        type: "geo";
        unique: boolean;
    } & {
        bestIndexedLevel: number;
        geoJson: boolean;
        legacyPolygons: boolean;
        maxNumCoverCells: number;
        worstIndexedLevel: number;
    } & {
        isNewlyCreated: boolean;
    }>>;
    ensureIndex(options): Promise<ArangoApiResponse<{
        fields: InvertedIndexField[];
        figures?: Record<string, any>;
        id: string;
        name: string;
        sparse: boolean;
        type: "inverted";
        unique: boolean;
    } & {
        analyzer: string;
        cache?: boolean;
        cleanupIntervalStep: number;
        commitIntervalMsec: number;
        consolidationIntervalMsec: number;
        consolidationPolicy: Required<TierConsolidationPolicy>;
        features: AnalyzerFeature[];
        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;
        writeBufferActive: number;
        writeBufferIdle: number;
        writeBufferSizeMax: number;
    } & {
        isNewlyCreated: boolean;
    }>>;
    ensureIndex(options): Promise<ArangoApiResponse<IndexDescription & {
        isNewlyCreated: boolean;
    }>>;
    exists(): Promise<boolean>;
    figures(details?): Promise<ArangoApiResponse<CollectionDescription & CollectionProperties & {
        count: number;
        figures: Record<string, any>;
    }>>;
    get(): Promise<ArangoApiResponse<CollectionDescription>>;
    getResponsibleShard(document): Promise<string>;
    import(data, options?): Promise<ImportDocumentsResult>;
    import(data, options?): Promise<ImportDocumentsResult>;
    import(data, options?): Promise<ImportDocumentsResult>;
    index(selector): Promise<IndexDescription>;
    indexes<IndexType>(options?): Promise<IndexType[]>;
    loadIndexes(): Promise<boolean>;
    properties(): Promise<ArangoApiResponse<CollectionDescription & CollectionProperties>>;
    properties(properties): Promise<ArangoApiResponse<CollectionDescription & 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<CollectionDescription>>;
    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<CollectionDescription & 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(options?): Promise<ArangoApiResponse<CollectionDescription>>;
    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
Type to represent document contents returned by the +server (including computed properties).
+ - EntryInputType extends Record<string, any> = EntryResultType
Type to represent document contents passed when +inserting or replacing documents (without computed properties).
+
Hierarchy (view full)
- ArangoCollection
- DocumentCollection
Index
Properties
Methods
Properties
Readonly database
Database this collection belongs to.
+Readonly name
Name of the collection.
+Methods
checksum
- checksum(options?): Promise<ArangoApiResponse<CollectionDescription & {
    checksum: string;
    revision: string;
}>> Retrieves the collection checksum.
+Parameters
Optionaloptions: CollectionChecksumOptionsOptions for retrieving the checksum.
+
Returns Promise<ArangoApiResponse<CollectionDescription & {
    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<CollectionDescription>>
Triggers compaction for a collection.
+Returns Promise<ArangoApiResponse<CollectionDescription>>
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<CollectionDescription & CollectionProperties & {
    count: number;
}>> Retrieves information about the number of documents in a collection.
+Returns Promise<ArangoApiResponse<CollectionDescription & 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<CollectionDescription & CollectionProperties>>
Creates a collection with the given
+optionsand the instance's name.See also databases.Database#createCollection and +databases.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: CollectionPropertiesOptions & {
    distributeShardsLike?: string;
    enforceReplicationFactor?: boolean;
    keyOptions?: CollectionKeyOptions;
    numberOfShards?: number;
    shardKeys?: string[];
    shardingStrategy?: ShardingStrategy;
    smartGraphAttribute?: string;
    smartJoinAttribute?: string;
    waitForSyncReplication?: boolean;
} & {
    type?: CollectionType;
}Options for creating the collection.
+
Returns Promise<ArangoApiResponse<CollectionDescription & 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: ReadDocumentOptionsOptions 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 | ObjectWithDocumentKey)[]
Array of document
+_key,_idor objects with either +of those properties (e.g. a document from this collection). Optionaloptions: BulkReadDocumentsOptionsOptions 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 | ObjectWithDocumentKey)[]
drop
- drop(options?): Promise<ArangoApiResponse<{
    id: string;
}>> Deletes the collection from the database.
+Parameters
Optionaloptions: CollectionDropOptionsOptions for dropping the collection.
+
Returns Promise<ArangoApiResponse<{
    id: string;
}>>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(options): Promise<ArangoApiResponse<{
    fields: string[];
    figures?: Record<string, any>;
    id: string;
    name: string;
    sparse: boolean;
    type: "persistent";
    unique: boolean;
} & {
    cacheEnabled: boolean;
    deduplicate: boolean;
    estimates: boolean;
    storedValues?: string[];
} & {
    isNewlyCreated: boolean;
}>> Creates a persistent index on the collection if it does not already exist.
+Parameters
- options: EnsurePersistentIndexOptions
Options for creating the persistent index.
+
Returns Promise<ArangoApiResponse<{
    fields: string[];
    figures?: Record<string, any>;
    id: string;
    name: string;
    sparse: boolean;
    type: "persistent";
    unique: boolean;
} & {
    cacheEnabled: boolean;
    deduplicate: boolean;
    estimates: boolean;
    storedValues?: string[];
} & {
    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
}); +- options: EnsurePersistentIndexOptions
- ensure
Index(options): Promise<ArangoApiResponse<{
    fields: [string];
    figures?: Record<string, any>;
    id: string;
    name: string;
    sparse: boolean;
    type: "ttl";
    unique: boolean;
} & {
    expireAfter: number;
    selectivityEstimate: number;
} & {
    isNewlyCreated: boolean;
}>> Creates a TTL index on the collection if it does not already exist.
+Parameters
- options: EnsureTtlIndexOptions
Options for creating the TTL index.
+
Returns Promise<ArangoApiResponse<{
    fields: [string];
    figures?: Record<string, any>;
    id: string;
    name: string;
    sparse: boolean;
    type: "ttl";
    unique: boolean;
} & {
    expireAfter: number;
    selectivityEstimate: number;
} & {
    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
}); +- options: EnsureTtlIndexOptions
- ensure
Index(options): Promise<ArangoApiResponse<{
    fields: string[];
    figures?: Record<string, any>;
    id: string;
    name: string;
    sparse: boolean;
    type: "mdi";
    unique: boolean;
} & {
    fieldValueTypes: "double";
} & {
    isNewlyCreated: boolean;
}>> Creates a multi-dimensional index on the collection if it does not already exist.
+Parameters
- options: EnsureMdiIndexOptions
Options for creating the multi-dimensional index.
+
Returns Promise<ArangoApiResponse<{
    fields: string[];
    figures?: Record<string, any>;
    id: string;
    name: string;
    sparse: boolean;
    type: "mdi";
    unique: boolean;
} & {
    fieldValueTypes: "double";
} & {
    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"
}); +
++- options: EnsureMdiIndexOptions
- ensure
Index(options): Promise<ArangoApiResponse<{
    fields: [string, string] | [string];
    figures?: Record<string, any>;
    id: string;
    name: string;
    sparse: boolean;
    type: "geo";
    unique: boolean;
} & {
    bestIndexedLevel: number;
    geoJson: boolean;
    legacyPolygons: boolean;
    maxNumCoverCells: number;
    worstIndexedLevel: number;
} & {
    isNewlyCreated: boolean;
}>> Creates a geo index on the collection if it does not already exist.
+Parameters
- options: EnsureGeoIndexOptions
Options for creating the geo index.
+
Returns Promise<ArangoApiResponse<{
    fields: [string, string] | [string];
    figures?: Record<string, any>;
    id: string;
    name: string;
    sparse: boolean;
    type: "geo";
    unique: boolean;
} & {
    bestIndexedLevel: number;
    geoJson: boolean;
    legacyPolygons: boolean;
    maxNumCoverCells: number;
    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
}); +- options: EnsureGeoIndexOptions
- ensure
Index(options): Promise<ArangoApiResponse<{
    fields: InvertedIndexField[];
    figures?: Record<string, any>;
    id: string;
    name: string;
    sparse: boolean;
    type: "inverted";
    unique: boolean;
} & {
    analyzer: string;
    cache?: boolean;
    cleanupIntervalStep: number;
    commitIntervalMsec: number;
    consolidationIntervalMsec: number;
    consolidationPolicy: Required<TierConsolidationPolicy>;
    features: AnalyzerFeature[];
    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;
    writeBufferActive: number;
    writeBufferIdle: number;
    writeBufferSizeMax: number;
} & {
    isNewlyCreated: boolean;
}>> Creates a inverted index on the collection if it does not already exist.
+Parameters
- options: EnsureInvertedIndexOptions
Options for creating the inverted index.
+
Returns Promise<ArangoApiResponse<{
    fields: InvertedIndexField[];
    figures?: Record<string, any>;
    id: string;
    name: string;
    sparse: boolean;
    type: "inverted";
    unique: boolean;
} & {
    analyzer: string;
    cache?: boolean;
    cleanupIntervalStep: number;
    commitIntervalMsec: number;
    consolidationIntervalMsec: number;
    consolidationPolicy: Required<TierConsolidationPolicy>;
    features: AnalyzerFeature[];
    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;
    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" }]
}); +- options: EnsureInvertedIndexOptions
- ensure
Index(options): Promise<ArangoApiResponse<IndexDescription & {
    isNewlyCreated: boolean;
}>> Creates an index on the collection if it does not already exist.
+Parameters
- options: EnsureIndexOptions
Options for creating the index.
+
Returns Promise<ArangoApiResponse<IndexDescription & {
    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
}); +- options: EnsureIndexOptions
exists
figures
- figures(details?): Promise<ArangoApiResponse<CollectionDescription & 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<CollectionDescription & 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<CollectionDescription>>
Retrieves general information about the collection.
+Returns Promise<ArangoApiResponse<CollectionDescription>>
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<ImportDocumentsResult>
Bulk imports the given
+datainto the collection.Parameters
- data: DocumentData<EntryInputType>[]
The data to import, as an array of document data.
+ Optionaloptions: ImportDocumentsOptionsOptions for importing the data.
+
Returns Promise<ImportDocumentsResult>
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<ImportDocumentsResult>
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: ImportDocumentsOptionsOptions for importing the data.
+
Returns Promise<ImportDocumentsResult>
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<ImportDocumentsResult>
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: ImportDocumentsOptions & {
    type?: "documents" | "list" | "auto";
}Options for importing the data.
+
Returns Promise<ImportDocumentsResult>
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<IndexDescription>
Returns an index description by name or
+idif it exists.Parameters
- selector: IndexSelector
Index name, id or object with either property.
+
Returns Promise<IndexDescription>
Example
+const db = new Database();
const collection = db.collection("some-collection");
const index = await collection.index("some-index"); +- selector: IndexSelector
indexes
- indexes<IndexType>(options?): Promise<IndexType[]>
Returns a list of all index descriptions for the collection.
+Type Parameters
- IndexType extends IndexDescription | HiddenIndexDescription = IndexDescription
Parameters
Optionaloptions: ListIndexesOptionsOptions for fetching the index list.
+
Returns Promise<IndexType[]>
Example
+const db = new Database();
const collection = db.collection("some-collection");
const indexes = await collection.indexes(); +Example
+const db = new Database();
const collection = db.collection("some-collection");
const allIndexes = await collection.indexes<HiddenIndexDescription>({
withHidden: true
}); +
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<CollectionDescription & CollectionProperties>>
Retrieves the collection's properties.
+Returns Promise<ArangoApiResponse<CollectionDescription & 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<CollectionDescription & CollectionProperties>>
Replaces the properties of the collection.
+Parameters
- properties: CollectionPropertiesOptions
Returns Promise<ArangoApiResponse<CollectionDescription & 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: RemoveDocumentOptionsOptions 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 | ObjectWithDocumentKey)[]
Documents
+_key,_idor objects with either of those +properties (e.g. documents from this collection). Optionaloptions: Omit<RemoveDocumentOptions, "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 | ObjectWithDocumentKey)[]
rename
- rename(newName): Promise<ArangoApiResponse<CollectionDescription>>
Renames the collection and updates the instance's
+nametonewName.Additionally removes the instance from the databases.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<CollectionDescription>>
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: ReplaceDocumentOptionsOptions 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<ReplaceDocumentOptions, "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<CollectionDescription & CollectionProperties & {
    revision: string;
}>> Retrieves the collection revision ID.
+Returns Promise<ArangoApiResponse<CollectionDescription & 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: InsertDocumentOptionsOptions 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: InsertDocumentOptionsOptions 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(options?): Promise<ArangoApiResponse<CollectionDescription>>
Deletes all documents in the collection.
+Parameters
Optionaloptions: CollectionTruncateOptions
Returns Promise<ArangoApiResponse<CollectionDescription>>
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: UpdateDocumentOptionsOptions 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<UpdateDocumentOptions, "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 databases.Database.
+See DocumentCollection for a more generic variant of this interface +more suited for regular document collections.
+See also graphs.GraphEdgeCollection for the type representing an edge +collection in a graphs.Graph.
+When using TypeScript, collections can be cast to a specific edge document +data type to increase type safety.
+Example
interface Friend {
startDate: number;
endDate?: number;
}
const db = new Database();
const edges = db.collection("friends") as EdgeCollection<Friend>;
+Â Â Â Â database: Database;
    name: string;
    checksum(options?): Promise<ArangoApiResponse<CollectionDescription & {
        checksum: string;
        revision: string;
    }>>;
    compact(): Promise<ArangoApiResponse<CollectionDescription>>;
    count(): Promise<ArangoApiResponse<CollectionDescription & CollectionProperties & {
        count: number;
    }>>;
    create(options?): Promise<ArangoApiResponse<CollectionDescription & 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<{
        id: string;
    }>>;
    dropIndex(selector): Promise<ArangoApiResponse<{
        id: string;
    }>>;
    edges(selector, options?): Promise<ArangoApiResponse<DocumentEdgesResult<EntryResultType>>>;
    ensureIndex(options): Promise<ArangoApiResponse<{
        fields: string[];
        figures?: Record<string, any>;
        id: string;
        name: string;
        sparse: boolean;
        type: "persistent";
        unique: boolean;
    } & {
        cacheEnabled: boolean;
        deduplicate: boolean;
        estimates: boolean;
        storedValues?: string[];
    } & {
        isNewlyCreated: boolean;
    }>>;
    ensureIndex(options): Promise<ArangoApiResponse<{
        fields: [string];
        figures?: Record<string, any>;
        id: string;
        name: string;
        sparse: boolean;
        type: "ttl";
        unique: boolean;
    } & {
        expireAfter: number;
        selectivityEstimate: number;
    } & {
        isNewlyCreated: boolean;
    }>>;
    ensureIndex(options): Promise<ArangoApiResponse<{
        fields: string[];
        figures?: Record<string, any>;
        id: string;
        name: string;
        sparse: boolean;
        type: "mdi";
        unique: boolean;
    } & {
        fieldValueTypes: "double";
    } & {
        isNewlyCreated: boolean;
    }>>;
    ensureIndex(options): Promise<ArangoApiResponse<{
        fields: [string, string] | [string];
        figures?: Record<string, any>;
        id: string;
        name: string;
        sparse: boolean;
        type: "geo";
        unique: boolean;
    } & {
        bestIndexedLevel: number;
        geoJson: boolean;
        legacyPolygons: boolean;
        maxNumCoverCells: number;
        worstIndexedLevel: number;
    } & {
        isNewlyCreated: boolean;
    }>>;
    ensureIndex(options): Promise<ArangoApiResponse<{
        fields: InvertedIndexField[];
        figures?: Record<string, any>;
        id: string;
        name: string;
        sparse: boolean;
        type: "inverted";
        unique: boolean;
    } & {
        analyzer: string;
        cache?: boolean;
        cleanupIntervalStep: number;
        commitIntervalMsec: number;
        consolidationIntervalMsec: number;
        consolidationPolicy: Required<TierConsolidationPolicy>;
        features: AnalyzerFeature[];
        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;
        writeBufferActive: number;
        writeBufferIdle: number;
        writeBufferSizeMax: number;
    } & {
        isNewlyCreated: boolean;
    }>>;
    ensureIndex(options): Promise<ArangoApiResponse<IndexDescription & {
        isNewlyCreated: boolean;
    }>>;
    exists(): Promise<boolean>;
    figures(details?): Promise<ArangoApiResponse<CollectionDescription & CollectionProperties & {
        count: number;
        figures: Record<string, any>;
    }>>;
    get(): Promise<ArangoApiResponse<CollectionDescription>>;
    getResponsibleShard(document): Promise<string>;
    import(data, options?): Promise<ImportDocumentsResult>;
    import(data, options?): Promise<ImportDocumentsResult>;
    import(data, options?): Promise<ImportDocumentsResult>;
    inEdges(selector, options?): Promise<ArangoApiResponse<DocumentEdgesResult<EntryResultType>>>;
    index(selector): Promise<IndexDescription>;
    indexes<IndexType>(options?): Promise<IndexType[]>;
    loadIndexes(): Promise<boolean>;
    outEdges(selector, options?): Promise<ArangoApiResponse<DocumentEdgesResult<EntryResultType>>>;
    properties(): Promise<ArangoApiResponse<CollectionDescription & CollectionProperties>>;
    properties(properties): Promise<ArangoApiResponse<CollectionDescription & 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<CollectionDescription>>;
    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<CollectionDescription & 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(options?): Promise<ArangoApiResponse<CollectionDescription>>;
    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
Type to represent edge document contents returned +by the server (including computed properties).
+ - EntryInputType extends Record<string, any> = EntryResultType
Type to represent edge document contents passed when +inserting or replacing edge documents (without computed properties).
+
Hierarchy (view full)
- DocumentCollection<EntryResultType, EntryInputType>
- EdgeCollection
Index
Properties
Methods
Properties
Readonly database
Database this collection belongs to.
+Readonly name
Name of the collection.
+Methods
checksum
- checksum(options?): Promise<ArangoApiResponse<CollectionDescription & {
    checksum: string;
    revision: string;
}>> Retrieves the collection checksum.
+Parameters
Optionaloptions: CollectionChecksumOptionsOptions for retrieving the checksum.
+
Returns Promise<ArangoApiResponse<CollectionDescription & {
    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<CollectionDescription>>
Triggers compaction for a collection.
+Returns Promise<ArangoApiResponse<CollectionDescription>>
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<CollectionDescription & CollectionProperties & {
    count: number;
}>> Retrieves information about the number of documents in a collection.
+Returns Promise<ArangoApiResponse<CollectionDescription & 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<CollectionDescription & CollectionProperties>>
Creates a collection with the given
+optionsand the instance's name.See also databases.Database#createCollection and +databases.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: CollectionPropertiesOptions & {
    distributeShardsLike?: string;
    enforceReplicationFactor?: boolean;
    keyOptions?: CollectionKeyOptions;
    numberOfShards?: number;
    shardKeys?: string[];
    shardingStrategy?: ShardingStrategy;
    smartGraphAttribute?: string;
    smartJoinAttribute?: string;
    waitForSyncReplication?: boolean;
} & {
    type?: CollectionType;
}Options for creating the collection.
+
Returns Promise<ArangoApiResponse<CollectionDescription & 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: ReadDocumentOptionsOptions 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 | ObjectWithDocumentKey)[]
Array of document
+_key,_idor objects with either +of those properties (e.g. a document from this collection). Optionaloptions: BulkReadDocumentsOptionsOptions 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 | ObjectWithDocumentKey)[]
drop
- drop(options?): Promise<ArangoApiResponse<{
    id: string;
}>> Deletes the collection from the database.
+Parameters
Optionaloptions: CollectionDropOptionsOptions for dropping the collection.
+
Returns Promise<ArangoApiResponse<{
    id: string;
}>>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<DocumentEdgesResult<EntryResultType>>>
Retrieves a list of all edges in this collection 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: DocumentEdgesOptionsOptions for retrieving the edges.
+
Returns Promise<ArangoApiResponse<DocumentEdgesResult<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(options): Promise<ArangoApiResponse<{
    fields: string[];
    figures?: Record<string, any>;
    id: string;
    name: string;
    sparse: boolean;
    type: "persistent";
    unique: boolean;
} & {
    cacheEnabled: boolean;
    deduplicate: boolean;
    estimates: boolean;
    storedValues?: string[];
} & {
    isNewlyCreated: boolean;
}>> Creates a persistent index on the collection if it does not already exist.
+Parameters
- options: EnsurePersistentIndexOptions
Options for creating the persistent index.
+
Returns Promise<ArangoApiResponse<{
    fields: string[];
    figures?: Record<string, any>;
    id: string;
    name: string;
    sparse: boolean;
    type: "persistent";
    unique: boolean;
} & {
    cacheEnabled: boolean;
    deduplicate: boolean;
    estimates: boolean;
    storedValues?: string[];
} & {
    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
}); +- options: EnsurePersistentIndexOptions
- ensure
Index(options): Promise<ArangoApiResponse<{
    fields: [string];
    figures?: Record<string, any>;
    id: string;
    name: string;
    sparse: boolean;
    type: "ttl";
    unique: boolean;
} & {
    expireAfter: number;
    selectivityEstimate: number;
} & {
    isNewlyCreated: boolean;
}>> Creates a TTL index on the collection if it does not already exist.
+Parameters
- options: EnsureTtlIndexOptions
Options for creating the TTL index.
+
Returns Promise<ArangoApiResponse<{
    fields: [string];
    figures?: Record<string, any>;
    id: string;
    name: string;
    sparse: boolean;
    type: "ttl";
    unique: boolean;
} & {
    expireAfter: number;
    selectivityEstimate: number;
} & {
    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
}); +- options: EnsureTtlIndexOptions
- ensure
Index(options): Promise<ArangoApiResponse<{
    fields: string[];
    figures?: Record<string, any>;
    id: string;
    name: string;
    sparse: boolean;
    type: "mdi";
    unique: boolean;
} & {
    fieldValueTypes: "double";
} & {
    isNewlyCreated: boolean;
}>> Creates a multi-dimensional index on the collection if it does not already exist.
+Parameters
- options: EnsureMdiIndexOptions
Options for creating the multi-dimensional index.
+
Returns Promise<ArangoApiResponse<{
    fields: string[];
    figures?: Record<string, any>;
    id: string;
    name: string;
    sparse: boolean;
    type: "mdi";
    unique: boolean;
} & {
    fieldValueTypes: "double";
} & {
    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"
}); +
++- options: EnsureMdiIndexOptions
- ensure
Index(options): Promise<ArangoApiResponse<{
    fields: [string, string] | [string];
    figures?: Record<string, any>;
    id: string;
    name: string;
    sparse: boolean;
    type: "geo";
    unique: boolean;
} & {
    bestIndexedLevel: number;
    geoJson: boolean;
    legacyPolygons: boolean;
    maxNumCoverCells: number;
    worstIndexedLevel: number;
} & {
    isNewlyCreated: boolean;
}>> Creates a geo index on the collection if it does not already exist.
+Parameters
- options: EnsureGeoIndexOptions
Options for creating the geo index.
+
Returns Promise<ArangoApiResponse<{
    fields: [string, string] | [string];
    figures?: Record<string, any>;
    id: string;
    name: string;
    sparse: boolean;
    type: "geo";
    unique: boolean;
} & {
    bestIndexedLevel: number;
    geoJson: boolean;
    legacyPolygons: boolean;
    maxNumCoverCells: number;
    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
}); +- options: EnsureGeoIndexOptions
- ensure
Index(options): Promise<ArangoApiResponse<{
    fields: InvertedIndexField[];
    figures?: Record<string, any>;
    id: string;
    name: string;
    sparse: boolean;
    type: "inverted";
    unique: boolean;
} & {
    analyzer: string;
    cache?: boolean;
    cleanupIntervalStep: number;
    commitIntervalMsec: number;
    consolidationIntervalMsec: number;
    consolidationPolicy: Required<TierConsolidationPolicy>;
    features: AnalyzerFeature[];
    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;
    writeBufferActive: number;
    writeBufferIdle: number;
    writeBufferSizeMax: number;
} & {
    isNewlyCreated: boolean;
}>> Creates a inverted index on the collection if it does not already exist.
+Parameters
- options: EnsureInvertedIndexOptions
Options for creating the inverted index.
+
Returns Promise<ArangoApiResponse<{
    fields: InvertedIndexField[];
    figures?: Record<string, any>;
    id: string;
    name: string;
    sparse: boolean;
    type: "inverted";
    unique: boolean;
} & {
    analyzer: string;
    cache?: boolean;
    cleanupIntervalStep: number;
    commitIntervalMsec: number;
    consolidationIntervalMsec: number;
    consolidationPolicy: Required<TierConsolidationPolicy>;
    features: AnalyzerFeature[];
    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;
    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" }]
}); +- options: EnsureInvertedIndexOptions
- ensure
Index(options): Promise<ArangoApiResponse<IndexDescription & {
    isNewlyCreated: boolean;
}>> Creates an index on the collection if it does not already exist.
+Parameters
- options: EnsureIndexOptions
Options for creating the index.
+
Returns Promise<ArangoApiResponse<IndexDescription & {
    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
}); +- options: EnsureIndexOptions
exists
figures
- figures(details?): Promise<ArangoApiResponse<CollectionDescription & 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<CollectionDescription & 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<CollectionDescription>>
Retrieves general information about the collection.
+Returns Promise<ArangoApiResponse<CollectionDescription>>
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<ImportDocumentsResult>
Bulk imports the given
+datainto the collection.Parameters
- data: EdgeData<EntryInputType>[]
The data to import, as an array of edge data.
+ Optionaloptions: ImportDocumentsOptionsOptions for importing the data.
+
Returns Promise<ImportDocumentsResult>
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<ImportDocumentsResult>
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: ImportDocumentsOptionsOptions for importing the data.
+
Returns Promise<ImportDocumentsResult>
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<ImportDocumentsResult>
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: ImportDocumentsOptions & {
    type?: "documents" | "list" | "auto";
}Options for importing the data.
+
Returns Promise<ImportDocumentsResult>
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<DocumentEdgesResult<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: DocumentEdgesOptionsOptions for retrieving the edges.
+
Returns Promise<ArangoApiResponse<DocumentEdgesResult<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<IndexDescription>
Returns an index description by name or
+idif it exists.Parameters
- selector: IndexSelector
Index name, id or object with either property.
+
Returns Promise<IndexDescription>
Example
+const db = new Database();
const collection = db.collection("some-collection");
const index = await collection.index("some-index"); +- selector: IndexSelector
indexes
- indexes<IndexType>(options?): Promise<IndexType[]>
Returns a list of all index descriptions for the collection.
+Type Parameters
- IndexType extends IndexDescription | HiddenIndexDescription = IndexDescription
Parameters
Optionaloptions: ListIndexesOptionsOptions for fetching the index list.
+
Returns Promise<IndexType[]>
Example
+const db = new Database();
const collection = db.collection("some-collection");
const indexes = await collection.indexes(); +Example
+const db = new Database();
const collection = db.collection("some-collection");
const allIndexes = await collection.indexes<HiddenIndexDescription>({
withHidden: true
}); +
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<DocumentEdgesResult<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: DocumentEdgesOptionsOptions for retrieving the edges.
+
Returns Promise<ArangoApiResponse<DocumentEdgesResult<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<CollectionDescription & CollectionProperties>>
Retrieves the collection's properties.
+Returns Promise<ArangoApiResponse<CollectionDescription & 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<CollectionDescription & CollectionProperties>>
Replaces the properties of the collection.
+Parameters
- properties: CollectionPropertiesOptions
Returns Promise<ArangoApiResponse<CollectionDescription & 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: RemoveDocumentOptionsOptions 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: RemoveDocumentOptionsOptions 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<CollectionDescription>>
Renames the collection and updates the instance's
+nametonewName.Additionally removes the instance from the databases.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<CollectionDescription>>
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: ReplaceDocumentOptionsOptions 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: ReplaceDocumentOptionsOptions 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<CollectionDescription & CollectionProperties & {
    revision: string;
}>> Retrieves the collection revision ID.
+Returns Promise<ArangoApiResponse<CollectionDescription & 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: InsertDocumentOptionsOptions 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: InsertDocumentOptionsOptions 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(options?): Promise<ArangoApiResponse<CollectionDescription>>
Deletes all documents in the collection.
+Parameters
Optionaloptions: CollectionTruncateOptions
Returns Promise<ArangoApiResponse<CollectionDescription>>
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: UpdateDocumentOptionsOptions 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: UpdateDocumentOptionsOptions 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 ProcessedResponse<T>
Processed response object.
+Â Â Â Â arrayBuffer: (() => Promise<ArrayBuffer>);
    blob: (() => Promise<Blob>);
    body: null | ReadableStream<any>;
    bodyUsed: boolean;
    clone: (() => Response);
    formData: (() => Promise<FormData>);
    headers: Headers;
    json: (() => Promise<unknown>);
    ok: boolean;
    parsedBody?: T;
    redirected: boolean;
    request: Request;
    status: number;
    statusText: string;
    text: (() => Promise<string>);
    type: ResponseType;
    url: string;
}
Type Parameters
Hierarchy
- Response
- ProcessedResponse
Index
Properties
Properties
Readonly array
Type declaration
- (): Promise<ArrayBuffer>
Returns Promise<ArrayBuffer>
Readonly blob
Type declaration
- (): Promise<Blob>
Returns Promise<Blob>
Readonly body
Readonly body
Readonly clone
Type declaration
- (): Response
Returns Response
Readonly form
Type declaration
- (): Promise<FormData>
Returns Promise<FormData>
Deprecated
This method is not recommended for parsing multipart/form-data bodies in server environments. +It is recommended to use a library such as @fastify/busboy as follows:
+Example
import { Busboy } from '@fastify/busboy'
import { Readable } from 'node:stream'
const response = await fetch('...')
const busboy = new Busboy({ headers: { 'content-type': response.headers.get('content-type') } })
// handle events emitted from `busboy`
Readable.fromWeb(response.body).pipe(busboy)
+Readonly headers
Readonly json
Type declaration
- (): Promise<unknown>
Returns Promise<unknown>
Readonly ok
Optional parsed
Parsed response body.
+Readonly redirected
request
Fetch request object.
+Readonly status
Readonly status
Readonly text
Type declaration
- (): Promise<string>
Returns Promise<string>
Readonly type
Readonly url
Interface BatchCursorItemsView<ItemType>
A low-level interface for consuming the items of a BatchCursor.
+Â Â Â Â isEmpty: boolean;
    more(): Promise<void>;
    shift(): undefined | ItemType;
}
Type Parameters
Properties
Readonly is
Methods
more
shift
Interface CreateArangoSearchViewStoredValueOptions
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 administration
import type { VersionInfo } from "arangojs/administration";
+The "administration" module provides types for database administration.
+Index
Interfaces
Type Aliases
Module analyzers
import type { Analyzer } from "arangojs/analyzers";
+The "analyzers" module provides Analyzer related types and interfaces +for TypeScript.
+Index
Classes
Type Aliases
Functions
Module aql
import { aql } from "arangojs/aql";
+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 cluster
import type { ClusterImbalanceInfo } from "arangojs/cluster";
+The "cluster" module provides types for cluster management.
+Index
Type Aliases
Module collections
import type {
DocumentCollection,
EdgeCollection,
} from "arangojs/collections";
+The "collections" module provides collection related types and interfaces +for TypeScript.
+Index
Enumerations
Interfaces
Type Aliases
Functions
Module connection
import type { Config } from "arangojs/connection";
+The "connection" module provides connection and configuration related types +for TypeScript.
+Index
Interfaces
Type Aliases
Module cursors
import type { Cursor, BatchCursor } from "arangojs/cursors";
+The "cursors" module provides cursor-related types and interfaces for +TypeScript.
+Index
Classes
Interfaces
Type Aliases
Module documents
import type { Document, Edge } from "arangojs/documents";
+The "documents" module provides document/edge related types for TypeScript.
+Index
Type Aliases
Module errors
import type { ArangoError, HttpError } from "arangojs/errors";
+The "errors" module provides types and interfaces for TypeScript related +to arangojs error handling.
+Index
Classes
Functions
Module foxx-manifest
import type { FoxxManifest } from "arangojs/foxx-manifest";
+The "foxx-manifest" module provides the Foxx manifest type for TypeScript.
+Generated from JSON Schema
+using json-schema-to-typescript.
Index
Type Aliases
Module graphs
import type {
Graph,
GraphVertexCollection,
GraphEdgeCollection,
} from "arangojs/graphs";
+The "graphs" module provides graph related types and interfaces +for TypeScript.
+Index
Classes
Type Aliases
Functions
Module hot-backups
import type { HotBackupOptions } from "arangojs/hot-backups";
+The "hot-backups" module provides types for managing hot backups.
+Index
Type Aliases
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 databases.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";
+The "indexes" module provides index-related types for TypeScript.
+Index
Type Aliases
Module jobs
import type { Job } from "arangojs/jobs";
+The "jobs" module provides job-related types for TypeScript.
+Index
Classes
Module logs
import type { LogLevel } from "arangojs/logs";
+The "logs" module provides types for ArangoDB logs.
+Index
Enumerations
Type Aliases
Module queries
import type { QueryOptions } from "arangojs/queries";
+The "query" module provides query related types for TypeScript.
+Index
Type Aliases
Module routes
import type { Route } from "arangojs/routes";
+The "routes" module provides route related types and interfaces for +TypeScript.
+Index
Classes
Module services
import type { ServiceInfo } from "arangojs/services";
+The "services" module provides types for Foxx services.
+Index
Type Aliases
Module transactions
import type { Transaction } from "arangojs/transactions";
+The "transactions" module provides transaction related types and interfaces +for TypeScript.
+Index
Classes
Type Aliases
Functions
Module users
import type { ArangoUser } from "arangojs/users";
+The "users" module provides types for ArangoDB users.
+Index
Type Aliases
Module views
import type { ArangoSearchView } from "arangojs/views";
+The "views" module provides View related types and interfaces for +TypeScript.
+Index
Classes
Interfaces
Type Aliases
Functions
Type alias ClusterSupportInfo
    date: string;
    deployment: {
        agents: number;
        coordinators: number;
        dbServers: number;
        servers: Record<string, Record<string, any>>;
        shards: {
            collections: number;
            followers: number;
            leaders: number;
            realLeaders: number;
            servers: number;
            shards: number;
        };
        type: "cluster";
    };
    host: Record<string, any>;
}
Cluster deployment information for support purposes.
+Type declaration
date: string
ISO 8601 datetime string of when the information was requested.
+deployment: {
    agents: number;
    coordinators: number;
    dbServers: number;
    servers: Record<string, Record<string, any>>;
    shards: {
        collections: number;
        followers: number;
        leaders: number;
        realLeaders: number;
        servers: number;
        shards: number;
    };
    type: "cluster";
}Information about the deployment.
+agents: number
Number of agents in the cluster.
+coordinators: number
Number of coordinators in the cluster.
+db
Servers: number Number of DB-Servers in the cluster.
+servers: Record<string, Record<string, any>>
Information about the servers in the cluster.
+shards: {
    collections: number;
    followers: number;
    leaders: number;
    realLeaders: number;
    servers: number;
    shards: number;
}Information about the shards in the cluster.
+collections: number
Number of collections in the cluster.
+followers: number
Number of followers in the cluster.
+leaders: number
Number of leaders in the cluster.
+real
Leaders: number Number of real leaders in the cluster.
+servers: number
Number of servers in the cluster.
+shards: number
Number of shards in the cluster.
+
type: "cluster"
Deployment mode:
+-
+
+"single": A single server deployment.
+
+"cluster": A cluster deployment.
+
host: Record<string, any>
(Cluster only.) Information about the ArangoDB instance as well as the +host machine.
+
Type alias EngineInfo
    endianness?: "little" | "big";
    name: string;
    supports?: {
        aliases?: {
            indexes?: Record<string, string>;
        };
        indexes?: string[];
    };
}
Information about the storage engine.
+Type declaration
Optionalendianness?: "little" | "big"Endianness of the storage engine.
+name: string
Name of the storage engine.
+Optionalsupports?: {
    aliases?: {
        indexes?: Record<string, string>;
    };
    indexes?: string[];
}Features supported by the storage engine.
+Optionalaliases?: {
    indexes?: Record<string, string>;
}Aliases supported by the storage engine.
+Optionalindexes?: Record<string, string>Index type aliases supported by the storage engine.
+
Optionalindexes?: string[]Index types supported by the storage engine.
+
Type alias ServerAvailability
Server availability.
+-
+
+"default": The server is operational.
+
+"readonly": The server is in read-only mode.
+
+false: The server is not available.
+
Type alias ServerStatusInformation
    address?: string;
    agency?: {
        agencyComm: {
            endpoints: string[];
        };
    };
    agent?: {
        endpoint: string;
        id: string;
        leaderId: string;
        leading: boolean;
        term: number;
    };
    coordinator?: {
        foxxmaster: string[];
        isFoxxmaster: boolean[];
    };
    foxxApi: boolean;
    host: string;
    hostname?: string;
    license: "community" | "enterprise";
    mode: "server" | "console";
    operationMode: "server" | "console";
    pid: number;
    server: "arango";
    serverInfo: {
        maintenance: boolean;
        persistedId?: string;
        progress: {
            feature: string;
            phase: string;
            recoveryTick: number;
        };
        readOnly: boolean;
        rebootId?: number;
        role: "SINGLE" | "COORDINATOR" | "PRIMARY" | "AGENT";
        serverId?: string;
        state?: "STARTUP" | "SERVING" | "SHUTDOWN";
        version: string;
        writeOpsEnabled: boolean;
    };
}
Information about the server status.
+Type declaration
Optionaladdress?: string(Cluster Coordinators and DB-Servers only.) The address of the server.
+Optionalagency?: {
    agencyComm: {
        endpoints: string[];
    };
}(Cluster Coordinators and DB-Servers only.) Information about the Agency.
+agency
Comm: {
    endpoints: string[];
}Information about the communication with the Agency.
+endpoints: string[]
A list of possible Agency endpoints.
+
Optionalagent?: {
    endpoint: string;
    id: string;
    leaderId: string;
    leading: boolean;
    term: number;
}(Cluster Agents only.) Information about the Agents.
+endpoint: string
The endpoint of the queried Agent.
+id: string
Server ID of the queried Agent.
+leader
Id: string Server ID of the leading Agent.
+leading: boolean
Whether the queried Agent is the leader.
+term: number
The current term number.
+
Optionalcoordinator?: {
    foxxmaster: string[];
    isFoxxmaster: boolean[];
}(Cluster Coordinators only.) Information about the Coordinators.
+foxxmaster: string[]
The server ID of the Coordinator that is the Foxx master.
+is
Foxxmaster: boolean[] Whether the queried Coordinator is the Foxx master.
+
foxx
Api: boolean Whether the Foxx API is enabled.
+host: string
A host identifier defined by the HOST or NODE_NAME environment variable, +or a fallback value using a machine identifier or the cluster/Agency address.
+Optionalhostname?: stringA hostname defined by the HOSTNAME environment variable.
+license: "community" | "enterprise"
ArangoDB Edition.
+mode: "server" | "console"
Server operation mode.
+Deprecated
use
+operationModeinsteadoperation
Mode: "server" | "console" Server operation mode.
+pid: number
The process ID of arangod.
+server: "arango"
Server type.
+server
Info: {
    maintenance: boolean;
    persistedId?: string;
    progress: {
        feature: string;
        phase: string;
        recoveryTick: number;
    };
    readOnly: boolean;
    rebootId?: number;
    role: "SINGLE" | "COORDINATOR" | "PRIMARY" | "AGENT";
    serverId?: string;
    state?: "STARTUP" | "SERVING" | "SHUTDOWN";
    version: string;
    writeOpsEnabled: boolean;
}Information about the server status.
+maintenance: boolean
Whether the maintenance mode is enabled.
+OptionalpersistedId?: string (Cluster only.) The persisted ID.
+progress: {
    feature: string;
    phase: string;
    recoveryTick: number;
}Startup and recovery information.
+feature: string
Internal name of the feature that is currently being prepared, started, stopped or unprepared.
+phase: string
Name of the lifecycle phase the instance is currently in.
+recovery
Tick: number Current recovery sequence number value.
+
read
Only: boolean Whether writes are disabled.
+OptionalrebootId?: number (Cluster only.) The reboot ID. Changes on every restart.
+role: "SINGLE" | "COORDINATOR" | "PRIMARY" | "AGENT"
Either "SINGLE", "COORDINATOR", "PRIMARY" (DB-Server), or "AGENT"
+OptionalserverId?: string (Cluster Coordinators and DB-Servers only.) The server ID.
+Optionalstate?: "STARTUP" | "SERVING" | "SHUTDOWN"(Cluster Coordinators and DB-Servers only.) Either "STARTUP", "SERVING", +or "SHUTDOWN".
+version: string
The server version string.
+write
Ops Enabled: boolean Whether writes are enabled.
+Deprecated
Use
+readOnlyinstead.
Type alias SingleServerSupportInfo
    date: string;
    deployment: {
        type: "single";
    };
}
Single server deployment information for support purposes.
+Type declaration
date: string
ISO 8601 datetime string of when the information was requested.
+deployment: {
    type: "single";
}Information about the deployment.
+type: "single"
Deployment mode:
+-
+
+"single": A single server deployment.
+
+"cluster": A cluster deployment.
+
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 AnalyzerDescription
An object describing an Analyzer.
+Type alias AnalyzerFeature
Name of a feature enabled for an Analyzer.
+Type alias AqlAnalyzerDescription
    batchSize: number;
    collapsePositions: boolean;
    keepNull: boolean;
    memoryLimit: number;
    queryString: string;
    returnType: AqlReturnTokenType;
}>
An object describing an AQL Analyzer
+Type declaration
batch
Size: number collapse
Positions: boolean keep
Null: boolean memory
Limit: number query
String: string return
Type: AqlReturnTokenType
Type alias AqlReturnTokenType
Token data type for an AQL Analyzer.
+Type alias CaseConversion
Text case conversion type.
+Type alias ClassificationAnalyzerDescription
    model_location: string;
    threshold: number;
    top_k: number;
}>
(Enterprise Edition only.) An object describing a Classification Analyzer
+Type declaration
model_
location: string threshold: number
top_
k: number
Type alias CollationAnalyzerDescription
    locale: string;
}>
An object describing a Collation Analyzer
+Type declaration
locale: string
Type alias CreateAnalyzerOptions
Analyzer type and its type-specific properties.
+Type alias CreateAqlAnalyzerOptions
    batchSize?: number;
    collapsePositions?: boolean;
    keepNull?: boolean;
    memoryLimit?: number;
    queryString: string;
    returnType?: AqlReturnTokenType;
}>
Options for creating an AQL Analyzer
+Type declaration
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?: AqlReturnTokenType Data type of the returned tokens.
+Default:
+"string"
Type alias CreateClassificationAnalyzerOptions
    model_location: string;
    threshold?: number;
    top_k?: number;
}>
(Enterprise Edition only.) Options for creating a Classification Analyzer
+Type declaration
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 alias CreateCollationAnalyzerOptions
    locale: string;
}>
Options for creating a Collation Analyzer
+Type declaration
locale: string
Text locale.
+Format:
+language[_COUNTRY][.encoding][@variant]
Type alias CreateDelimiterAnalyzerOptions
    delimiter: string;
}>
Options for creating a Delimiter Analyzer.
+Type alias CreateGeoJsonAnalyzerOptions
    options?: {
        maxCells?: number;
        maxLevel?: number;
        minLevel?: number;
    };
    type?: GeoType;
}>
Options for creating a GeoJSON Analyzer
+Type declaration
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?: GeoTypeIf 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 alias CreateGeoPointAnalyzerOptions
    latitude?: string[];
    longitude?: string[];
    options?: {
        maxLevel?: number;
        minCells?: number;
        minLevel?: number;
    };
}>
Options for creating a GeoPoint Analyzer
+Type declaration
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 alias CreateGeoS2AnalyzerOptions
    format?: GeoS2Format;
    options?: {
        maxCells?: number;
        maxLevel?: number;
        minLevel?: number;
    };
    type?: GeoType;
}>
(Enterprise Edition only.) Options for creating a Geo S2 Analyzer
+Type declaration
Optionalformat?: GeoS2FormatIf 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?: GeoTypeIf 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 alias CreateIdentityAnalyzerOptions
Options for creating an Identity Analyzer.
+Type alias CreateMinHashAnalyzerOptions
    analyzer: Omit<CreateAnalyzerOptions, "features">;
    numHashes: number;
}>
(Enterprise Edition only.) Options for creating a MinHash Analyzer
+Type declaration
analyzer: Omit<CreateAnalyzerOptions, "features">
An Analyzer definition-like object with
+typeandpropertiesattributes.num
Hashes: number Size of the MinHash signature.
+
Type alias CreateMultiDelimiterAnalyzerOptions
    delimiters: string[];
}>
Options for creating a Multi-Delimiter Analyzer.
+Type declaration
delimiters: string[]
This value will be used as delimiter to split text into tokens as +specified in RFC 4180, without starting new records on newlines.
+
Type alias CreateNearestNeighborsAnalyzerOptions
    model_location: string;
    top_k?: number;
}>
(Enterprise Edition only.) Options for creating a NearestNeighbors Analyzer.
+Type declaration
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 alias CreateNgramAnalyzerOptions
    max: number;
    min: number;
    preserveOriginal: boolean;
}>
Options for creating an Ngram Analyzer.
+Type declaration
max: number
Maximum n-gram length.
+min: number
Minimum n-gram length.
+preserve
Original: boolean Output the original value as well.
+
Type alias CreateNormAnalyzerOptions
    accent?: boolean;
    case?: CaseConversion;
    locale: string;
}>
Options for creating a Norm Analyzer.
+Type declaration
Optionalaccent?: booleanPreserve accents in returned words.
+Default:
+falseOptionalcase?: CaseConversionCase conversion.
+Default:
+"lower"locale: string
Text locale.
+Format:
+language[_COUNTRY][.encoding][@variant]
Type alias CreatePipelineAnalyzerOptions
    pipeline: Omit<CreateAnalyzerOptions, "features">[];
}>
Options for creating a Pipeline Analyzer
+Type declaration
pipeline: Omit<CreateAnalyzerOptions, "features">[]
Definitions for Analyzers to chain in this Pipeline Analyzer.
+
Type alias CreateSegmentationAnalyzerOptions
    break?: SegmentationTokenType;
    case?: CaseConversion;
}>
Options for creating a Segmentation Analyzer
+Type declaration
Optionalbreak?: SegmentationTokenTypeWhich tokens should be returned.
+Default:
+"alpha"Optionalcase?: CaseConversionWhat case all returned tokens should be converted to if applicable.
+Default:
+"none"
Type alias CreateStemAnalyzerOptions
    locale: string;
}>
Options for creating a Stem Analyzer.
+Type declaration
locale: string
Text locale.
+Format:
+language[_COUNTRY][.encoding][@variant]
Type alias CreateStopwordsAnalyzerOptions
    hex?: boolean;
    stopwords: string[];
}>
Options for creating a Stopwords Analyzer
+Type declaration
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 alias CreateTextAnalyzerOptions
    accent?: boolean;
    case?: CaseConversion;
    edgeNgram?: {
        max?: number;
        min?: number;
        preserveOriginal?: boolean;
    };
    locale: string;
    stemming?: boolean;
    stopwords?: string[];
    stopwordsPath?: string;
}>
Options for creating a Text Analyzer.
+Type declaration
Optionalaccent?: booleanPreserve accents in returned words.
+Default:
+falseOptionalcase?: CaseConversionCase 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 alias CreateWildcardAnalyzerOptions
    analyzer?: Omit<CreateAnalyzerOptions, "features">;
    ngramSize: string;
}>
Options for creating a Wildcard Analyzer.
+Type declaration
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 alias DelimiterAnalyzerDescription
    delimiter: string;
}>
An object describing a Delimiter Analyzer.
+Type declaration
delimiter: string
Type alias GeoJsonAnalyzerDescription
    description: {
        maxCells: number;
        maxLevel: number;
        minLevel: number;
    };
    type: GeoType;
}>
An object describing a GeoJSON Analyzer
+Type declaration
description: {
    maxCells: number;
    maxLevel: number;
    minLevel: number;
}max
Cells: number max
Level: number min
Level: number
type: GeoType
Type alias GeoPointAnalyzerDescription
    description: {
        maxLevel: number;
        minCells: number;
        minLevel: number;
    };
    latitude: string[];
    longitude: string[];
}>
An object describing a GeoPoint Analyzer
+Type declaration
description: {
    maxLevel: number;
    minCells: number;
    minLevel: number;
}max
Level: number min
Cells: number min
Level: number
latitude: string[]
longitude: string[]
Type alias GeoS2AnalyzerDescription
    description: {
        maxCells: number;
        maxLevel: number;
        minLevel: number;
    };
    format: GeoS2Format;
    type: GeoType;
}>
(Enterprise Edition only.) An object describing a GeoS2 Analyzer
+Type declaration
description: {
    maxCells: number;
    maxLevel: number;
    minLevel: number;
}max
Cells: number max
Level: number min
Level: number
format: GeoS2Format
type: GeoType
Type alias GeoS2Format
Storage format of a Geo S2 Analyzer.
+Type alias GeoType
GeoJSON type.
+Type alias IdentityAnalyzerDescription
An object describing an Identity Analyzer.
+Type alias MinHashAnalyzerDescription
    analyzer: Omit<AnalyzerDescription, "name" | "features">;
    numHashes: number;
}>
(Enterprise Edition only.) An object describing a MinHash Analyzer
+Type declaration
analyzer: Omit<AnalyzerDescription, "name" | "features">
num
Hashes: number
Type alias MultiDelimiterAnalyzerDescription
    delimiters: string[];
}>
An object describing a Multi Delimiter Analyzer.
+Type declaration
delimiters: string[]
Type alias NearestNeighborsAnalyzerDescription
    model_location: string;
    top_k: number;
}>
(Enterprise Edition only.) An object describing a NearestNeighbors Analyzer
+Type declaration
model_
location: string top_
k: number
Type alias NgramAnalyzerDescription
    max: number;
    min: number;
    preserveOriginal: boolean;
}>
An object describing an Ngram Analyzer.
+Type declaration
max: number
min: number
preserve
Original: boolean
Type alias NormAnalyzerDescription
    accent: boolean;
    case: CaseConversion;
    locale: string;
}>
An object describing a Norm Analyzer.
+Type declaration
accent: boolean
case: CaseConversion
locale: string
Type alias PipelineAnalyzerDescription
    pipeline: Omit<AnalyzerDescription, "name" | "features">[];
}>
An object describing a Pipeline Analyzer
+Type declaration
pipeline: Omit<AnalyzerDescription, "name" | "features">[]
Type alias SegmentationAnalyzerDescription
    break: SegmentationTokenType;
    case: CaseConversion;
}>
An object describing a Segmentation Analyzer
+Type declaration
break: SegmentationTokenType
case: CaseConversion
Type alias SegmentationTokenType
Token type for a Segmentation Analyzer.
+Type alias StemAnalyzerDescription
    locale: string;
}>
An object describing a Stem Analyzer.
+Type declaration
locale: string
Type alias StopwordsAnalyzerDescription
    hex: boolean;
    stopwords: string[];
}>
An object describing a Stopwords Analyzer
+Type declaration
hex: boolean
stopwords: string[]
Type alias TextAnalyzerDescription
    accent: boolean;
    case: CaseConversion;
    edgeNgram: {
        max: number;
        min: number;
        preserveOriginal: boolean;
    };
    locale: string;
    stemming: boolean;
    stopwords: string[];
    stopwordsPath: string;
}>
An object describing a Text Analyzer.
+Type declaration
accent: boolean
case: CaseConversion
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 alias WildcardAnalyzerDescription
    analyzer?: Omit<AnalyzerDescription, "name" | "features">;
    ngramSize: number;
}>
An object describing a Wildcard Analyzer
+Type declaration
Optionalanalyzer?: Omit<AnalyzerDescription, "name" | "features">ngram
Size: number
Type alias AqlValue
A value that can be used in an AQL template string or passed to an AQL +helper function.
+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[];
}
The result of a cluster rebalance.
+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 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 CollectionDescription
    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 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 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 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 If set to
+true, data will be synchronized to disk before returning from +a document create, update, replace or removal operation.Default:
+falseOptionalwriteConcern?: number (Cluster only.) Write concern for this collection.
+
Type alias CollectionTruncateOptions
    compact?: boolean;
    waitForSync?: boolean;
}
Options for truncating collections.
+Type declaration
Optionalcompact?: booleanWhether the collection should be compacted after truncation.
+OptionalwaitFor Sync?: boolean Whether data should be synchronized to disk before returning from this +operation.
+
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
    distributeShardsLike?: string;
    enforceReplicationFactor?: boolean;
    keyOptions?: CollectionKeyOptions;
    numberOfShards?: number;
    shardKeys?: string[];
    shardingStrategy?: ShardingStrategy;
    smartGraphAttribute?: string;
    smartJoinAttribute?: string;
    waitForSyncReplication?: boolean;
}
Options for creating a collection.
+See databases.Database#createCollection, databases.Database#createEdgeCollection +and DocumentCollection#create or EdgeCollection#create.
+Type declaration
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:
+1OptionalshardKeys?: 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 Replication?: boolean (Cluster only.) Unless set to
+false, the server will wait for all +replicas to create the collection before returning.Default:
+true
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
    level: ValidationLevel;
    message: string;
    rule: any;
    type: "json";
}
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 | Promise<void>);
    arangoVersion?: number;
    auth?: BasicAuthCredentials | BearerAuthCredentials;
    beforeRequest?: ((req) => void | Promise<void>);
    credentials?: "omit" | "include" | "same-origin";
    databaseName?: string;
    headers?: Headers | Record<string, string>;
    keepalive?: boolean;
    loadBalancingStrategy?: LoadBalancingStrategy;
    maxRetries?: false | number;
    onError?: ((err) => void | Promise<void>);
    poolSize?: number;
    precaptureStackTraces?: boolean;
    responseQueueTimeSamples?: number;
    retryOnConflict?: number;
    url?: string | string[];
}
Options for configuring arangojs.
+Type declaration
OptionalafterResponse?: ((err, res?) => void | Promise<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 | Promise<void>
Parameters
- err: NetworkError | null
Error encountered when handling this request or
+null. Optionalres: globalThis.Response & {
    request: globalThis.Request;
}Response object for this request, if no error occurred.
+
Returns void | Promise<void>
- err: NetworkError | 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 databases.Database#useBasicAuth and +databases.Database#useBearerAuth.
+Default:
+{ username: "root", password: "" }OptionalbeforeRequest?: ((req) => void | Promise<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 | Promise<void>
Parameters
- req: globalThis.Request
Request object or XHR instance used for this request.
+
Returns void | Promise<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 databases.Database#useBasicAuth, databases.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:
+0OptionalonError?: ((err) => void | Promise<void>) Callback that will be invoked when a request
+- (err): void | Promise<void>
Parameters
- err: Error
Error encountered when handling this request.
+
Returns void | Promise<void>
- err: Error
OptionalpoolSize?: 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 databases.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 databases.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.
+
Type alias CursorExtras
    plan?: Record<string, any>;
    profile?: Record<string, number>;
    stats?: CursorStats;
    warnings: {
        code: number;
        message: string;
    }[];
}
Additional information about the cursor.
+Type declaration
Optionalplan?: Record<string, any>Query execution plan for the executed query.
+Optionalprofile?: Record<string, number>Additional profiling information for the executed query.
+Optionalstats?: CursorStatsAdditional statistics about the query execution.
+warnings: {
    code: number;
    message: string;
}[]Warnings encountered while executing the query.
+
Type alias CursorStats
    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;
}
Additional statics about the query execution of the cursor.
+Type declaration
cache
Hits: number Total number of index entries read from in-memory caches for indexes of +type edge or persistent.
+cache
Misses: number 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
Created: number Total number of cursor objects created during query execution.
+cursors
Rearmed: number Total number of times an existing cursor object was repurposed.
+execution
Time: number Execution time of the query in seconds.
+filtered: number
Total number of documents that were removed after executing a filter condition in a FilterNode.
+OptionalfullCount?: number Total number of documents that matched the search condition if the query’s final top-level LIMIT statement were not present.
+http
Requests: number Total number of cluster-internal HTTP requests performed.
+Optionalnodes?: {
    calls: number;
    filter: number;
    id: number;
    items: number;
    runtime: number;
}[]Runtime statistics per query execution node if
+profilewas set to2or greater.peak
Memory Usage: number Maximum memory usage of the query while it was running.
+scanned
Full: number Total number of documents iterated over when scanning a collection without an index.
+scanned
Index: number Total number of documents iterated over when scanning a collection using an index.
+writes
Executed: number Total number of data-modification operations successfully executed.
+writes
Ignored: number Total number of data-modification operations that were unsuccessful, but have been ignored because of query option ignoreErrors.
+
Type alias CreateDatabaseOptions
    replicationFactor?: "satellite" | number;
    sharding?: "" | "flexible" | "single";
    users?: CreateDatabaseUserOptions[];
    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?: CreateDatabaseUserOptions[]Database users to create with the database.
+OptionalwriteConcern?: number (Cluster only.) Default write concern for new collections created in this +database.
+
Type alias DatabaseDescription
    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 BulkReadDocumentsOptions
    allowDirtyRead?: boolean;
    ignoreRevs?: 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.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:
+true
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 DocumentEdgesOptions
    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 DocumentExistsOptions
    allowDirtyRead?: boolean;
    ifMatch?: string;
    ifNoneMatch?: string;
}
Options for checking whether a document exists in 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.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 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 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 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.
See DocumentMetadata.
+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 ImportDocumentsOptions
    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 ImportDocumentsResult
    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 InsertDocumentOptions
    keepNull?: boolean;
    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
OptionalkeepNull?: 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 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 ObjectWithDocumentId
    _id: string;
    [key: string]: any;
}
An object with an ArangoDB document _id property.
See DocumentMetadata.
+Type declaration
[key: string]: any
_id: string
Type alias ObjectWithDocumentKey
    _key: string;
    [key: string]: any;
}
An object with an ArangoDB document _key property.
See DocumentMetadata.
+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 ReadDocumentOptions
    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 RemoveDocumentOptions
    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 ReplaceDocumentOptions
    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 UpdateDocumentOptions
    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 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
Options for adding an edge definition to a graph.
+Type declaration
Optionalsatellites?: (string | ArangoCollection)[](Enterprise Edition cluster only.) Collections to be included in a Hybrid +SmartGraph.
+
Type alias AddVertexCollectionOptions
Options for adding a vertex collection to a graph.
+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.
+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.
+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 GraphDescription
    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 InsertGraphDocumentOptions
    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 ReadGraphDocumentOptions
    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 RemoveGraphDocumentOptions
    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 ReplaceEdgeDefinitionOptions
    satellites?: string[];
}
Options for replacing an edge definition in a graph.
+Type declaration
Optionalsatellites?: string[](Enterprise Edition cluster only.) Collections to be included in a Hybrid +SmartGraph.
+
Type alias ReplaceGraphDocumentOptions
    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 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 ArangosearchIndexDescription
    analyzers: string[];
    fields: Record<string, Record<string, any>>;
    figures?: Record<string, any>;
    id: string;
    includeAllFields: boolean;
    storeValues: "none" | "id";
    trackListPositions: boolean;
    type: "arangosearch";
    view: string;
}
An object representing an arangosearch index.
+Type declaration
analyzers: string[]
fields: Record<string, Record<string, any>>
Optionalfigures?: Record<string, any>id: string
include
All Fields: boolean store
Values: "none" | "id" track
List Positions: boolean type: "arangosearch"
view: string
Type alias EnsureGeoIndexOptions
    geoJson?: boolean;
    legacyPolygons?: boolean;
}>
Options for creating a geo index.
+Type declaration
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.If set to
+false,fieldscan be either an array containing two +attribute paths, the first of which will be interpreted as the latitude +and the second as the longitude, or a single attribute path for an array +containing two values, the first of which will be interpreted as the +latitude, the second as the longitude.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.
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[];
    includeAllFields?: boolean;
    optimizeTopK?: string[];
    parallelism?: number;
    primaryKeyCache?: boolean;
    primarySort?: InvertedIndexPrimarySortOptions;
    searchField?: boolean;
    storedValues?: InvertedIndexStoredValueOptions[];
    trackListPositions?: boolean;
    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.
+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.Default:
+falseOptionaloptimizeTopK?: 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?: InvertedIndexPrimarySortOptions Primary sort order to optimize AQL queries using a matching sort order.
+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:
+falseOptionalwriteBuffer 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";
    unique?: boolean;
}>
Options for creating a MDI index.
+Type declaration
field
Value Types: "double" Data type of the dimension attributes.
+Optionalunique?: booleanIf set to
+true, a unique index will be created.Default:
+false
Type alias EnsurePersistentIndexOptions
    cacheEnabled?: boolean;
    deduplicate?: boolean;
    estimates?: boolean;
    sparse?: boolean;
    storedValues?: string[];
    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:
+trueOptionalsparse?: 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.
+Optionalunique?: booleanIf set to
+true, a unique index will be created.Default:
+false
Type alias EnsureTtlIndexOptions
    expireAfter: number;
}>
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.
+
Type alias GeoIndexDescription
    bestIndexedLevel: number;
    geoJson: boolean;
    legacyPolygons: boolean;
    maxNumCoverCells: number;
    worstIndexedLevel: number;
}>
An object representing a geo index.
+Type declaration
best
Indexed Level: number geo
Json: boolean legacy
Polygons: boolean max
Num Cover Cells: number worst
Indexed Level: number
Type alias HiddenIndexDescription
    progress?: number;
}
An object representing a potentially hidden index.
+This type can be used to cast the result of collection.indexes to better
+reflect the actual data returned by the server when using the withHidden
+option:
const indexes = await collection.indexes<HiddenIndex>({
withHidden: true
}));
// indexes may include internal indexes and indexes with a "progress"
// property
+Type declaration
Optionalprogress?: numberProgress of this index if it is still being created.
+
Type alias IndexDescription
An object representing an index.
+Type alias IndexDescriptionType<Type, Fields, Extra>
    fields: Fields;
    figures?: Record<string, any>;
    id: string;
    name: string;
    sparse: boolean;
    type: Type;
    unique: boolean;
} & Extra
Shared attributes of all index types.
+Type Parameters
Type declaration
fields: Fields
An array of attribute paths.
+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.
+sparse: boolean
Whether documents not containing at least one of the attribute paths +are omitted by this index.
+type: Type
Type of this index.
+unique: boolean
Whether this index enforces uniqueness for values of its attribute paths.
+
Type alias IndexSelector
Index name, id or object with a name or id property.
Type alias InternalIndexDescription
An object representing an internal index.
+Type alias InternalIndexType
Type of an internal index.
+Type alias InvertedIndexDescription
    analyzer: string;
    cache?: boolean;
    cleanupIntervalStep: number;
    commitIntervalMsec: number;
    consolidationIntervalMsec: number;
    consolidationPolicy: Required<TierConsolidationPolicy>;
    features: AnalyzerFeature[];
    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;
    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[]
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 write
Buffer Active: number write
Buffer Idle: number write
Buffer Size Max: number
Type alias InvertedIndexField
    analyzer?: string;
    cache?: boolean;
    features?: AnalyzerFeature[];
    includeAllFields?: boolean;
    name: string;
    nested?: InvertedIndexNestedField[];
    searchField?: boolean;
    trackListPositions?: boolean;
}
An object representing a field in an inverted index.
+Type declaration
Optionalanalyzer?: stringOptionalcache?: booleanOptionalfeatures?: AnalyzerFeature[]OptionalincludeAll Fields?: boolean name: string
Optionalnested?: InvertedIndexNestedField[]OptionalsearchField?: boolean OptionaltrackList Positions?: boolean
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 InvertedIndexPrimarySortFieldOptions
Options for defining a primary sort field on an inverted index.
+Type declaration
direction: Direction
The sorting direction.
+field: string
The attribute path to sort by.
+
Type alias InvertedIndexPrimarySortOptions
    cache?: boolean;
    compression?: Compression;
    fields: InvertedIndexPrimarySortFieldOptions[];
}
Options for defining a primary sort field on an inverted index.
+Type declaration
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.
+
Type alias InvertedIndexStoredValueOptions
    cache?: boolean;
    compression?: Compression;
    fields: string[];
}
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 ListIndexesOptions
    withHidden?: boolean;
    withStats?: boolean;
}
Options for listing indexes.
+Type declaration
OptionalwithHidden?: boolean If set to
+true, includes internal indexes as well as indexes that are +not yet fully built but are in the building phase.You should cast the resulting indexes to
+HiddenIndexto ensure internal +and incomplete indexes are accurately represented.Default:
+false.OptionalwithStats?: boolean If set to
+true, includes additional information about each index.Default:
+false
Type alias MdiIndexDescription
An object representing a MDI index.
+Type declaration
field
Value Types: "double"
Type alias ObjectWithIndexId
    id: string;
    [key: string]: any;
}
An object with an id property.
Type declaration
[key: string]: any
id: string
Type alias ObjectWithName
    name: string;
    [key: string]: any;
}
An object with a name property.
Type declaration
[key: string]: any
name: string
Type alias PersistentIndexDescription
    cacheEnabled: boolean;
    deduplicate: boolean;
    estimates: boolean;
    storedValues?: string[];
}>
An object representing a persistent index.
+Type declaration
cache
Enabled: boolean deduplicate: boolean
estimates: boolean
OptionalstoredValues?: string[]
Type alias PrimaryIndexDescription
    selectivityEstimate: number;
}>
An object representing a primary index.
+Type declaration
selectivity
Estimate: number
Type alias SystemIndexDescription
An object representing a system index.
+Type alias TtlIndexDescription
    expireAfter: number;
    selectivityEstimate: number;
}>
An object representing a TTL index.
+Type declaration
expire
After: number selectivity
Estimate: number
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
    date: string;
    id: number;
    level: LogLevelLabel;
    message: string;
    topic: string;
}
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 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 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 ParseResult
    ast: AstNode[];
    bindVars: string[];
    collections: string[];
    parsed: boolean;
}
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 QueryDescription
    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.
+ +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 QueryTrackingInfo
    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.
+See Database#queryTracking.
+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 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 UserFunctionDescription
    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.
+See Database#createFunction.
+name: string
Name of the AQL User Function.
+
Type alias InstallServiceOptions
    configuration?: Record<string, any>;
    dependencies?: Record<string, string>;
    development?: boolean;
    legacy?: boolean;
    setup?: boolean;
}
Options for installing the service.
+See Database#installService.
+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 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 ReplaceServiceOptions
    configuration?: Record<string, any>;
    dependencies?: Record<string, string>;
    development?: boolean;
    force?: boolean;
    legacy?: boolean;
    setup?: boolean;
    teardown?: boolean;
}
Options for replacing a service.
+See Database#replaceService.
+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 ServiceDescription
    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
    suites: ServiceTestSuite[];
    tests: ServiceTestSuiteTest[];
    title: string;
}
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 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 UninstallServiceOptions
    force?: boolean;
    teardown?: boolean;
}
Options for uninstalling a service.
+See Database#uninstallService.
+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.
+See Database#upgradeService.
+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 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 TransactionCollectionOptions
    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 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 TransactionDetails
    id: string;
    state: "running" | "committed" | "aborted";
}
Details for a transaction.
+See also TransactionInfo.
+Type declaration
id: string
Unique identifier of the transaction.
+state: "running" | "committed" | "aborted"
Status (or "state") of the transaction.
+
Type alias TransactionInfo
    id: string;
    status: "running" | "committed" | "aborted";
}
Status of a given transaction.
+See also TransactionDetails.
+Type declaration
id: string
Unique identifier of the transaction.
+status: "running" | "committed" | "aborted"
Status 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 AccessLevel
Access level for an ArangoDB user's access to a collection or database.
+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 CreateDatabaseUserOptions
    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 UserAccessLevelOptions
    collection?: ArangoCollection | string;
    database?: Database | string;
}
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 ArangoSearchViewDescription
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 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?: CreateArangoSearchViewPrimarySortOptions[];
    primarySortCache?: boolean;
    primarySortCompression?: Compression;
    storedValues?: CreateArangoSearchViewStoredValueOptions[] | string[] | string[][];
    writebufferActive?: number;
    writebufferIdle?: number;
    writebufferSizeMax?: number;
}>
Options for creating an ArangoSearch View.
+Type alias CreateArangoSearchViewPrimarySortOptions
    direction: Direction;
    field: string;
} | {
    asc: boolean;
    field: string;
}
Options for creating a primary sort in an ArangoSearch View.
+Type declaration
direction: Direction
If set to
+"asc", the primary sorting order will be ascending. +If set to"desc", the primary sorting order will be descending.field: string
Attribute path for the value of each document to use for +sorting.
+
Type declaration
asc: boolean
If set to
+true, the primary sorting order will be ascending. +If set tofalse, the primary sorting order will be descending.field: string
Attribute path for the value of each document to use for +sorting.
+
Type alias CreateSearchAliasViewOptions
Options for creating a SearchAlias View.
+Type alias CreateViewOptions
Options for creating a View.
+Type alias Direction
Sorting direction. Descending or ascending.
+Type alias SearchAliasViewDescription
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 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 UpdateArangoSearchViewPropertiesOptions
Options for partially modifying the properties of an ArangoSearch View.
+Type alias UpdateSearchAliasViewIndexOptions
    operation?: "add" | "del";
}
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 UpdateSearchAliasViewPropertiesOptions
Options for partially modifying the properties of a SearchAlias View.
+Type declaration
indexes: UpdateSearchAliasViewIndexOptions[]
An array of inverted indexes to add to the View.
+
Type alias UpdateViewPropertiesOptions
Options for partially modifying a View's properties.
+Type alias ViewDescription
Type alias ViewDescriptionType<Type>
    globallyUniqueId: string;
    id: string;
    name: string;
    type: Type;
}
Generic description of a View.
+Type Parameters
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: Type
Type of the View.
+
Type alias ViewProperties
Type alias ViewPropertiesOptions
Options for replacing a View's properties.
+
Represents an Analyzer in a databases.Database.
+