@azure/cosmos
Version:
Microsoft Azure Cosmos DB Service Node.js SDK for NOSQL API
184 lines (183 loc) • 8.73 kB
JavaScript
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var changeFeedUtils_exports = {};
__export(changeFeedUtils_exports, {
buildFeedOptions: () => buildFeedOptions,
buildInternalChangeFeedOptions: () => buildInternalChangeFeedOptions,
decryptChangeFeedResponse: () => decryptChangeFeedResponse,
extractOverlappingRanges: () => extractOverlappingRanges,
fetchStartTime: () => fetchStartTime,
getEPKRangeForPrefixPartitionKey: () => getEPKRangeForPrefixPartitionKey,
getEffectivePartitionKeyForMultiHashPartitioning: () => getEffectivePartitionKeyForMultiHashPartitioning,
isEpkRange: () => isEpkRange,
isNullOrEmpty: () => isNullOrEmpty,
validateChangeFeedIteratorOptions: () => validateChangeFeedIteratorOptions
});
module.exports = __toCommonJS(changeFeedUtils_exports);
var import_request = require("../../request/index.js");
var import_typeChecks = require("../../utils/typeChecks.js");
var import_ChangeFeedStartFromBeginning = require("./ChangeFeedStartFromBeginning.js");
var import_common = require("../../common/index.js");
var import_ChangeFeedStartFromTime = require("./ChangeFeedStartFromTime.js");
var import_routing = require("../../routing/index.js");
var import_FeedRange = require("./FeedRange.js");
var import_v2 = require("../../utils/hashing/v2.js");
var import_ChangeFeedMode = require("./ChangeFeedMode.js");
function validateChangeFeedIteratorOptions(options) {
if (!isChangeFeedIteratorOptions(options)) {
throw new import_request.ErrorResponse("Invalid Changefeed Iterator Options.");
}
if (options?.maxItemCount && typeof options?.maxItemCount !== "number") {
throw new import_request.ErrorResponse("maxItemCount must be number");
}
if (options?.maxItemCount !== void 0 && options?.maxItemCount < 1) {
throw new import_request.ErrorResponse("maxItemCount must be a positive number");
}
}
function isChangeFeedIteratorOptions(options) {
if (typeof options !== "object") {
return false;
}
if (Object.keys(options).length === 0 && JSON.stringify(options) === "{}") {
return true;
}
return options && !((0, import_typeChecks.isPrimitivePartitionKeyValue)(options) || Array.isArray(options));
}
async function extractOverlappingRanges(epkRange, overLappingRange) {
if (overLappingRange.minInclusive >= epkRange.min && overLappingRange.maxExclusive <= epkRange.max) {
return [void 0, void 0];
} else if (overLappingRange.minInclusive <= epkRange.min && overLappingRange.maxExclusive >= epkRange.max) {
return [epkRange.min, epkRange.max];
} else if (overLappingRange.minInclusive <= epkRange.min && overLappingRange.maxExclusive <= epkRange.max && overLappingRange.maxExclusive >= epkRange.min) {
return [epkRange.min, overLappingRange.maxExclusive];
} else {
return [overLappingRange.minInclusive, epkRange.max];
}
}
function isEpkRange(obj) {
return obj instanceof import_FeedRange.FeedRangeInternal && typeof obj.minInclusive === "string" && typeof obj.maxExclusive === "string" && obj.minInclusive >= import_common.Constants.EffectivePartitionKeyConstants.MinimumInclusiveEffectivePartitionKey && obj.maxExclusive <= import_common.Constants.EffectivePartitionKeyConstants.MaximumExclusiveEffectivePartitionKey && obj.maxExclusive > obj.minInclusive;
}
function buildInternalChangeFeedOptions(options, continuationToken, startTime, startFromNow) {
const internalCfOptions = {};
internalCfOptions.maxItemCount = options?.maxItemCount;
internalCfOptions.sessionToken = options?.sessionToken;
internalCfOptions.continuationToken = continuationToken;
internalCfOptions.changeFeedMode = options?.changeFeedMode;
internalCfOptions.excludedLocations = options?.excludedLocations;
internalCfOptions.priorityLevel = options?.priorityLevel;
internalCfOptions.throughputBucket = options?.throughputBucket;
if (startFromNow) {
internalCfOptions.startFromNow = true;
} else {
internalCfOptions.startTime = startTime;
}
return internalCfOptions;
}
function fetchStartTime(changeFeedStartFrom) {
if (changeFeedStartFrom instanceof import_ChangeFeedStartFromBeginning.ChangeFeedStartFromBeginning) {
return void 0;
} else if (changeFeedStartFrom instanceof import_ChangeFeedStartFromTime.ChangeFeedStartFromTime) {
return changeFeedStartFrom.getStartTime();
}
}
function isNullOrEmpty(text) {
return text === null || text === void 0 || text.trim() === "";
}
async function getEPKRangeForPrefixPartitionKey(internalPartitionKey) {
const minEPK = getEffectivePartitionKeyForMultiHashPartitioning(internalPartitionKey);
const maxEPK = minEPK + import_common.Constants.EffectivePartitionKeyConstants.MaximumExclusiveEffectivePartitionKey;
return new import_routing.QueryRange(minEPK, maxEPK, true, false);
}
function getEffectivePartitionKeyForMultiHashPartitioning(partitionKeyInternal) {
const hashArray = partitionKeyInternal.map((item) => (0, import_v2.hashV2PartitionKey)([item]));
return hashArray.join("");
}
async function decryptChangeFeedResponse(result, diagnosticNode, changeFeedMode, encryptionProcessor) {
let count = 0;
diagnosticNode.beginEncryptionDiagnostics(import_common.Constants.Encryption.DiagnosticsDecryptOperation);
for (let item of result.result) {
if (changeFeedMode === import_ChangeFeedMode.ChangeFeedMode.AllVersionsAndDeletes) {
if ("current" in item && item.current !== null) {
const { body, propertiesDecryptedCount } = await encryptionProcessor.decrypt(item.current);
item.current = body;
count += propertiesDecryptedCount;
}
if ("previous" in item && item.previous !== null) {
const { body, propertiesDecryptedCount } = await encryptionProcessor.decrypt(item.previous);
item.previous = body;
count += propertiesDecryptedCount;
}
} else {
const { body, propertiesDecryptedCount } = await encryptionProcessor.decrypt(item);
item = body;
count += propertiesDecryptedCount;
}
}
diagnosticNode.endEncryptionDiagnostics(import_common.Constants.Encryption.DiagnosticsDecryptOperation, count);
}
function buildFeedOptions(changeFeedOptions, continuationToken, startFromNow, startTime) {
const feedOptions = {
initialHeaders: {},
useLatestVersionFeed: true,
useAllVersionsAndDeletesFeed: false
};
if (typeof changeFeedOptions.maxItemCount === "number") {
feedOptions.maxItemCount = changeFeedOptions.maxItemCount;
}
if (changeFeedOptions.sessionToken) {
feedOptions.sessionToken = changeFeedOptions.sessionToken;
}
if (changeFeedOptions.excludedLocations) {
feedOptions.excludedLocations = changeFeedOptions.excludedLocations;
}
if (continuationToken) {
feedOptions.accessCondition = {
type: import_common.Constants.HttpHeaders.IfNoneMatch,
condition: continuationToken
};
} else if (startFromNow) {
feedOptions.initialHeaders[import_common.Constants.HttpHeaders.IfNoneMatch] = import_common.Constants.ChangeFeedIfNoneMatchStartFromNowHeader;
}
if (startTime) {
feedOptions.initialHeaders[import_common.Constants.HttpHeaders.IfModifiedSince] = startTime;
}
if (changeFeedOptions.changeFeedMode && changeFeedOptions.changeFeedMode === import_ChangeFeedMode.ChangeFeedMode.AllVersionsAndDeletes) {
feedOptions.useAllVersionsAndDeletesFeed = true;
feedOptions.useLatestVersionFeed = false;
}
if (changeFeedOptions.throughputBucket) {
feedOptions.throughputBucket = changeFeedOptions.throughputBucket;
}
if (changeFeedOptions.priorityLevel) {
feedOptions.priorityLevel = changeFeedOptions.priorityLevel;
}
return feedOptions;
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
buildFeedOptions,
buildInternalChangeFeedOptions,
decryptChangeFeedResponse,
extractOverlappingRanges,
fetchStartTime,
getEPKRangeForPrefixPartitionKey,
getEffectivePartitionKeyForMultiHashPartitioning,
isEpkRange,
isNullOrEmpty,
validateChangeFeedIteratorOptions
});