Cosmos DB: Bulk operations can go over the 2Mb limit

[ealsur]

• Package Name: @azure/cosmos
• Package Version: All
• Operating system:
• nodejs

Describe the bug
Cosmos DB has a limit in the request size to 2Mb. When Bulk is used, the SDK applies hashing to distribute documents across partitions/batches and then sends them:

azure-sdk-for-js/sdk/cosmosdb/cosmos/src/client/Item/Items.ts

Lines 403 to 471 in e6dbd47

	public async bulk(
	operations: OperationInput[],
	bulkOptions?: BulkOptions,
	options?: RequestOptions
	): Promise<OperationResponse[]> {
	const { resources: partitionKeyRanges } = await this.container
	.readPartitionKeyRanges()
	.fetchAll();
	const { resource: definition } = await this.container.getPartitionKeyDefinition();
	const batches: Batch[] = partitionKeyRanges.map((keyRange: PartitionKeyRange) => {
	return {
	min: keyRange.minInclusive,
	max: keyRange.maxExclusive,
	rangeId: keyRange.id,
	indexes: [],
	operations: [],
	};
	});
	operations
	.map((operation) => decorateOperation(operation, definition, options))
	.forEach((operation: Operation, index: number) => {
	const partitionProp = definition.paths[0].replace("/", "");
	const isV2 = definition.version && definition.version === 2;
	const toHashKey = getPartitionKeyToHash(operation, partitionProp);
	const hashed = isV2 ? hashV2PartitionKey(toHashKey) : hashV1PartitionKey(toHashKey);
	const batchForKey = batches.find((batch: Batch) => {
	return isKeyInRange(batch.min, batch.max, hashed);
	});
	batchForKey.operations.push(operation);
	batchForKey.indexes.push(index);
	});
	const path = getPathFromLink(this.container.url, ResourceType.item);
	const orderedResponses: OperationResponse[] = [];
	await Promise.all(
	batches
	.filter((batch: Batch) => batch.operations.length)
	.map(async (batch: Batch) => {
	if (batch.operations.length > 100) {
	throw new Error("Cannot run bulk request with more than 100 operations per partition");
	}
	try {
	const response = await this.clientContext.bulk({
	body: batch.operations,
	partitionKeyRangeId: batch.rangeId,
	path,
	resourceId: this.container.url,
	bulkOptions,
	options,
	});
	response.result.forEach((operationResponse: OperationResponse, index: number) => {
	orderedResponses[batch.indexes[index]] = operationResponse;
	});
	} catch (err) {
	// In the case of 410 errors, we need to recompute the partition key ranges
	// and redo the batch request, however, 410 errors occur for unsupported
	// partition key types as well since we don't support them, so for now we throw
	if (err.code === 410) {
	throw new Error(
	"Partition key error. Either the partitions have split or an operation has an unsupported partitionKey type"
	);
	}
	throw new Error(`Bulk request errored with: ${err.message}`);
	}
	})
	);
	return orderedResponses;
	}

For each batch (physical partition) it will send 1 request with all the operations.

The problem is that the volume of operations for a single partition can exceed the 2Mb, there is no limiting or filtering happening.

In other Cosmos DB SDKs with Bulk, there is a size limiting factor being applied:

• .NET https://github.com/Azure/azure-cosmos-dotnet-v3/blob/master/Microsoft.Azure.Cosmos/src/Batch/BatchAsyncBatcher.cs#L105
• Java https://github.com/Azure/azure-sdk-for-java/blob/main/sdk/cosmos/azure-cosmos/src/main/java/com/azure/cosmos/implementation/batch/BulkExecutor.java#L493

To Reproduce

1. Send through Bulk a volume of operations (less than 100) that surpasses 2Mb in total size.

Expected behavior
The SDK would split the operations into requests less than 2Mb size