@azure/cosmos

property hasMoreResults

readonly hasMoreResults: boolean;

• Gets a value indicating whether there are potentially additional results that can be retrieved.

  Initially returns true. This value is set based on whether the last execution returned a continuation token.

  Returns

  Boolean value representing if whether there are potentially additional results that can be retrieved.

method fetchNext

fetchNext: () => Promise<ChangeFeedResponse<Array<T & Resource>>>;

• Read feed and retrieves the next page of results in Azure Cosmos DB.

method getAsyncIterator

getAsyncIterator: () => AsyncIterable<ChangeFeedResponse<Array<T & Resource>>>;

• Gets an async iterator which will yield pages of results from Azure Cosmos DB.

property activityId

readonly activityId: string;

• Gets the activity ID for the request from the Azure Cosmos DB service.

property continuation

readonly continuation: string;

• Gets the continuation token to be used for continuing enumeration of the Azure Cosmos DB service.

  This is equivalent to the etag property.

property count

readonly count: number;

• Gets the number of items returned in the response from Azure Cosmos DB

property etag

readonly etag: string;

• Gets the entity tag associated with last transaction in the Azure Cosmos DB service, which can be used as If-Non-Match Access condition for ReadFeed REST request or continuation property of ChangeFeedOptions parameter for Items.changeFeed() to get feed changes since the transaction specified by this entity tag.

  This is equivalent to the continuation property.

property headers

headers: CosmosHeaders;

• Response headers of the response from Azure Cosmos DB

property requestCharge

readonly requestCharge: number;

• Gets the request charge for this request from the Azure Cosmos DB service.

property result

readonly result: {};

• Gets the items returned in the response from Azure Cosmos DB

property sessionToken

readonly sessionToken: string;

• Gets the session token for use in session consistency reads from the Azure Cosmos DB service.

property statusCode

readonly statusCode: number;

• Gets the status code of the response from Azure Cosmos DB

constructor

constructor(
    cosmosClientOptions: CosmosClientOptions,
    globalEndpointManager: GlobalEndpointManager
);

property partitionKeyDefinitionCache

partitionKeyDefinitionCache: { [containerUrl: string]: any };

method batch

batch: <T>({
    body,
    path,
    partitionKey,
    resourceId,
    options,
}: {
    body: T;
    path: string;
    partitionKey: string;
    resourceId: string;
    options?: RequestOptions;
}) => Promise<Response_2<any>>;

method bulk

bulk: <T>({
    body,
    path,
    partitionKeyRangeId,
    resourceId,
    bulkOptions,
    options,
}: {
    body: T;
    path: string;
    partitionKeyRangeId: string;
    resourceId: string;
    bulkOptions?: BulkOptions;
    options?: RequestOptions;
}) => Promise<Response_2<any>>;

method clearSessionToken

clearSessionToken: (path: string) => void;

method create

create: <T, U = T>({
    body,
    path,
    resourceType,
    resourceId,
    options,
    partitionKey,
}: {
    body: T;
    path: string;
    resourceType: ResourceType;
    resourceId: string;
    options?: RequestOptions;
    partitionKey?: PartitionKey;
}) => Promise<Response_2<T & U & Resource>>;

method delete

delete: <T>({
    path,
    resourceType,
    resourceId,
    options,
    partitionKey,
    method,
}: {
    path: string;
    resourceType: ResourceType;
    resourceId: string;
    options?: RequestOptions;
    partitionKey?: PartitionKey;
    method?: HTTPMethod;
}) => Promise<Response_2<T & Resource>>;

method execute

execute: <T>({
    sprocLink,
    params,
    options,
    partitionKey,
}: {
    sprocLink: string;
    params?: any[];
    options?: RequestOptions;
    partitionKey?: PartitionKey;
}) => Promise<Response_2<T>>;

method getDatabaseAccount

getDatabaseAccount: (
    options?: RequestOptions
) => Promise<Response_2<DatabaseAccount>>;

• Gets the Database account information.

  Parameter options

  urlConnection in the options is the endpoint url whose database account needs to be retrieved. If not present, current client's url will be used.

method getQueryPlan

getQueryPlan: (
    path: string,
    resourceType: ResourceType,
    resourceId: string,
    query: SqlQuerySpec | string,
    options?: FeedOptions
) => Promise<Response_2<PartitionedQueryExecutionInfo>>;

method getReadEndpoint

getReadEndpoint: () => Promise<string>;

method getReadEndpoints

getReadEndpoints: () => Promise<readonly string[]>;

method getWriteEndpoint

getWriteEndpoint: () => Promise<string>;

method getWriteEndpoints

getWriteEndpoints: () => Promise<readonly string[]>;

method patch

patch: <T>({
    body,
    path,
    resourceType,
    resourceId,
    options,
    partitionKey,
}: {
    body: any;
    path: string;
    resourceType: ResourceType;
    resourceId: string;
    options?: RequestOptions;
    partitionKey?: PartitionKey;
}) => Promise<Response_2<T & Resource>>;

method queryFeed

queryFeed: <T>({
    path,
    resourceType,
    resourceId,
    resultFn,
    query,
    options,
    partitionKeyRangeId,
    partitionKey,
}: {
    path: string;
    resourceType: ResourceType;
    resourceId: string;
    resultFn: (result: { [key: string]: any }) => any[];
    query: SqlQuerySpec | string;
    options: FeedOptions;
    partitionKeyRangeId?: string;
    partitionKey?: PartitionKey;
}) => Promise<Response_2<T & Resource>>;

method queryPartitionKeyRanges

queryPartitionKeyRanges: (
    collectionLink: string,
    query?: string | SqlQuerySpec,
    options?: FeedOptions
) => QueryIterator<PartitionKeyRange>;

method read

read: <T>({
    path,
    resourceType,
    resourceId,
    options,
    partitionKey,
}: {
    path: string;
    resourceType: ResourceType;
    resourceId: string;
    options?: RequestOptions;
    partitionKey?: PartitionKey;
}) => Promise<Response_2<T & Resource>>;

method replace

replace: <T>({
    body,
    path,
    resourceType,
    resourceId,
    options,
    partitionKey,
}: {
    body: any;
    path: string;
    resourceType: ResourceType;
    resourceId: string;
    options?: RequestOptions;
    partitionKey?: PartitionKey;
}) => Promise<Response_2<T & Resource>>;

method upsert

upsert: <T, U = T>({
    body,
    path,
    resourceType,
    resourceId,
    options,
    partitionKey,
}: {
    body: T;
    path: string;
    resourceType: ResourceType;
    resourceId: string;
    options?: RequestOptions;
    partitionKey?: PartitionKey;
}) => Promise<Response_2<T & U & Resource>>;

constructor

constructor(requestCharge: number);

property requestCharge

readonly requestCharge: number;

property zero

static readonly zero: ClientSideMetrics;

method add

add: (...clientSideMetricsArray: ClientSideMetrics[]) => ClientSideMetrics;

• Adds one or more ClientSideMetrics to a copy of this instance and returns the result.

method createFromArray

static createFromArray: (
    ...clientSideMetricsArray: ClientSideMetrics[]
) => ClientSideMetrics;

constructor

constructor(
    container: Container,
    id: string,
    clientContext: ClientContext,
    partitionKey?: {}
);

• Parameter container

  The parent Container.

  Parameter id

  The id of the given Conflict.

property container

readonly container: Container;

property id

readonly id: string;

property url

readonly url: string;

• Returns a reference URL to the resource. Used for linking in Permissions.

method delete

delete: (options?: RequestOptions) => Promise<ConflictResponse>;

• Delete the given ConflictDefinition.

method read

read: (options?: RequestOptions) => Promise<ConflictResponse>;

• Read the ConflictDefinition for the given Conflict.

constructor

constructor(
    resource: ConflictDefinition & Resource,
    headers: CosmosHeaders,
    statusCode: number,
    conflict: Conflict
);

property conflict

readonly conflict: Conflict;

• A reference to the Conflict corresponding to the returned ConflictDefinition.

constructor

constructor(container: Container, clientContext: ClientContext);

property container

readonly container: Container;

method query

query: {
    (query: string | SqlQuerySpec, options?: FeedOptions): QueryIterator<any>;
    <T>(query: string | SqlQuerySpec, options?: FeedOptions): QueryIterator<T>;
};

• Queries all conflicts.

  Parameter query

  Query configuration for the operation. See SqlQuerySpec for more info on how to configure a query.

  Parameter options

  Use to set options like response page size, continuation tokens, etc.

  Returns

  QueryIterator Allows you to return results in an array or iterate over them one at a time.

• Queries all conflicts.

  Parameter query

  Query configuration for the operation. See SqlQuerySpec for more info on how to configure a query.

  Parameter options

  Use to set options like response page size, continuation tokens, etc.

  Returns

  QueryIterator Allows you to return results in an array or iterate over them one at a time.

method readAll

readAll: (options?: FeedOptions) => QueryIterator<ConflictDefinition & Resource>;

• Reads all conflicts

  Parameter options

  Use to set options like response page size, continuation tokens, etc.

constructor

constructor(database: Database, id: string, clientContext: ClientContext);

• Returns a container instance. Note: You should get this from database.container(id), rather than creating your own object.

  Parameter database

  The parent Database.

  Parameter id

  The id of the given container.

property conflicts

readonly conflicts: Conflicts;

• Operations for reading and querying conflicts for the given container.

  For reading or deleting a specific conflict, use .conflict(id).

property database

readonly database: Database;

property id

readonly id: string;

property items

readonly items: Items;

• Operations for creating new items, and reading/querying all items

  For reading, replacing, or deleting an existing item, use .item(id).

  Example 1

  Create a new item

  const {body: createdItem} = await container.items.create({id: "<item id>", properties: {}});

property scripts

readonly scripts: Scripts;

• All operations for Stored Procedures, Triggers, and User Defined Functions

property url

readonly url: string;

• Returns a reference URL to the resource. Used for linking in Permissions.

method conflict

conflict: (id: string, partitionKey?: PartitionKey) => Conflict;

• Used to read, replace, or delete a specific, existing Conflict by id.

  Use .conflicts for creating new conflicts, or querying/reading all conflicts.

  Parameter id

  The id of the Conflict.

method delete

delete: (options?: RequestOptions) => Promise<ContainerResponse>;

• Delete the container

method deleteAllItemsForPartitionKey

deleteAllItemsForPartitionKey: (
    partitionKey: PartitionKey,
    options?: RequestOptions
) => Promise<ContainerResponse>;

• Delete all documents belong to the container for the provided partition key value

  Parameter partitionKey

  The partition key value of the items to be deleted

method getPartitionKeyDefinition

getPartitionKeyDefinition: () => Promise<
    ResourceResponse<PartitionKeyDefinition>
>;

• Gets the partition key definition first by looking into the cache otherwise by reading the collection.

  Deprecated

  This method has been renamed to readPartitionKeyDefinition.

method getQueryPlan

getQueryPlan: (
    query: string | SqlQuerySpec
) => Promise<Response_2<PartitionedQueryExecutionInfo>>;

method item

item: (id: string, partitionKeyValue?: PartitionKey) => Item;

• Used to read, replace, or delete a specific, existing Item by id.

  Use .items for creating new items, or querying/reading all items.

  Parameter id

  The id of the Item.

  Parameter partitionKeyValue

  The value of the Item partition key

  Example 1

  Replace an item const {body: replacedItem} = await container.item("<item id>", "<partition key value>").replace({id: "<item id>", title: "Updated post", authorID: 5});

method read

read: (options?: RequestOptions) => Promise<ContainerResponse>;

• Read the container's definition

method readOffer

readOffer: (options?: RequestOptions) => Promise<OfferResponse>;

• Gets offer on container. If none exists, returns an OfferResponse with undefined.

method readPartitionKeyDefinition

readPartitionKeyDefinition: () => Promise<
    ResourceResponse<PartitionKeyDefinition>
>;

• Gets the partition key definition first by looking into the cache otherwise by reading the collection.

method readPartitionKeyRanges

readPartitionKeyRanges: (
    feedOptions?: FeedOptions
) => QueryIterator<PartitionKeyRange>;

method replace

replace: (
    body: ContainerDefinition,
    options?: RequestOptions
) => Promise<ContainerResponse>;

• Replace the container's definition

constructor

constructor(
    resource: ContainerDefinition & Resource,
    headers: CosmosHeaders,
    statusCode: number,
    container: Container
);

property container

readonly container: Container;

• A reference to the Container that the returned ContainerDefinition corresponds to.

constructor

constructor(database: Database, clientContext: ClientContext);

property database

readonly database: Database;

method create

create: (
    body: ContainerRequest,
    options?: RequestOptions
) => Promise<ContainerResponse>;

• Creates a container.

  A container is a named logical container for items.

  A database may contain zero or more named containers and each container consists of zero or more JSON items.

  Being schema-free, the items in a container do not need to share the same structure or fields.

  Since containers are application resources, they can be authorized using either the master key or resource keys.

  Parameter body

  Represents the body of the container.

  Parameter options

  Use to set options like response page size, continuation tokens, etc.

method createIfNotExists

createIfNotExists: (
    body: ContainerRequest,
    options?: RequestOptions
) => Promise<ContainerResponse>;

• Checks if a Container exists, and, if it doesn't, creates it. This will make a read operation based on the id in the body, then if it is not found, a create operation. You should confirm that the output matches the body you passed in for non-default properties (i.e. indexing policy/etc.)

  A container is a named logical container for items.

  A database may contain zero or more named containers and each container consists of zero or more JSON items.

  Being schema-free, the items in a container do not need to share the same structure or fields.

  Since containers are application resources, they can be authorized using either the master key or resource keys.

  Parameter body

  Represents the body of the container.

  Parameter options

  Use to set options like response page size, continuation tokens, etc.

method query

query: {
    (query: SqlQuerySpec, options?: FeedOptions): QueryIterator<any>;
    <T>(query: SqlQuerySpec, options?: FeedOptions): QueryIterator<T>;
};

• Queries all containers.

  Parameter query

  Query configuration for the operation. See SqlQuerySpec for more info on how to configure a query.

  Parameter options

  Use to set options like response page size, continuation tokens, etc.

  Returns

  QueryIterator Allows you to return specific containers in an array or iterate over them one at a time.

  Example 1

  Read all containers to array.

  const querySpec: SqlQuerySpec = {
    query: "SELECT * FROM root r WHERE r.id = @container",
    parameters: [
      {name: "@container", value: "Todo"}
    ]
  };
  const {body: containerList} = await client.database("<db id>").containers.query(querySpec).fetchAll();

• Queries all containers.

  Parameter query

  Query configuration for the operation. See SqlQuerySpec for more info on how to configure a query.

  Parameter options

  Use to set options like response page size, continuation tokens, etc.

  Returns

  QueryIterator Allows you to return specific containers in an array or iterate over them one at a time.

  Example 1

  Read all containers to array.

  const querySpec: SqlQuerySpec = {
    query: "SELECT * FROM root r WHERE r.id = @container",
    parameters: [
      {name: "@container", value: "Todo"}
    ]
  };
  const {body: containerList} = await client.database("<db id>").containers.query(querySpec).fetchAll();

method readAll

readAll: (
    options?: FeedOptions
) => QueryIterator<ContainerDefinition & Resource>;

• Read all containers.

  Parameter options

  Use to set options like response page size, continuation tokens, etc.

  Returns

  QueryIterator Allows you to return all containers in an array or iterate over them one at a time.

  Example 1

  Read all containers to array.

  const {body: containerList} = await client.database("<db id>").containers.readAll().fetchAll();

constructor

constructor(connectionString: string);

• Creates a new CosmosClient object from a connection string. Your database connection string can be found in the Azure Portal

constructor

constructor(options: CosmosClientOptions);