@datastax/astra-db-ts
Version:
Data API TypeScript client
106 lines (105 loc) • 4.25 kB
JavaScript
;
// Copyright Datastax, Inc
// SPDX-License-Identifier: Apache-2.0
Object.defineProperty(exports, "__esModule", { value: true });
exports.insertManyUnordered = exports.insertManyOrdered = void 0;
const errors_js_1 = require("../../../documents/errors.js");
const ctx_js_1 = require("../../../lib/api/ser-des/ctx.js");
const utils_js_1 = require("../../../lib/utils.js");
const insertManyOrdered = async (httpClient, serdes, documents, chunkSize, timeoutManager, err) => {
const insertedIds = [];
for (let i = 0, n = documents.length; i < n; i += chunkSize) {
const slice = documents.slice(i, i + chunkSize);
const extraLogInfo = (documents.length === slice.length)
? { records: documents.length, ordered: true }
: { records: documents.length, slice: `${i}..${i + slice.length}`, ordered: true };
const resp = await insertMany(httpClient, serdes, slice, true, timeoutManager, extraLogInfo);
insertedIds.push(...resp.insertedIds);
if (resp.error) {
throw new err([resp.error], {
insertedIds: insertedIds,
insertedCount: insertedIds.length,
});
}
}
return insertedIds;
};
exports.insertManyOrdered = insertManyOrdered;
const insertManyUnordered = async (httpClient, serdes, documents, concurrency, chunkSize, timeoutManager, err) => {
const insertedIds = [];
let masterIndex = 0;
const docResps = [];
const errors = [];
const promises = Array.from({ length: concurrency }, async () => {
while (masterIndex < documents.length) {
const localI = masterIndex;
const endIdx = Math.min(localI + chunkSize, documents.length);
masterIndex += chunkSize;
const slice = documents.slice(localI, endIdx);
const extraLogInfo = (documents.length === slice.length)
? { records: documents.length, ordered: false }
: { records: documents.length, slice: `${localI}..${endIdx}`, ordered: false };
const resp = await insertMany(httpClient, serdes, slice, false, timeoutManager, extraLogInfo);
insertedIds.push(...resp.insertedIds);
docResps.push(...resp.documentResponses);
if (resp.error) {
errors.push(resp.error);
}
}
});
await Promise.all(promises);
if ((0, utils_js_1.isNonEmpty)(errors)) {
throw new err(errors, {
insertedIds: insertedIds,
insertedCount: insertedIds.length,
});
}
return insertedIds;
};
exports.insertManyUnordered = insertManyUnordered;
const insertMany = async (httpClient, serdes, documents, ordered, timeoutManager, extraLogInfo) => {
let raw, err;
try {
const serialized = [];
let bigNumsPresent = false;
for (let i = 0, n = documents.length; i < n; i++) {
const resp = serdes.serialize(documents[i], ctx_js_1.SerDesTarget.Record);
serialized.push(resp[0]);
bigNumsPresent || (bigNumsPresent = resp[1]);
}
raw = await httpClient.executeCommand({
insertMany: {
documents: serialized,
options: {
returnDocumentResponses: true,
ordered,
},
},
}, { timeoutManager, bigNumsPresent, extraLogInfo: extraLogInfo });
}
catch (e) {
if (!(e instanceof errors_js_1.DataAPIResponseError)) {
throw e;
}
raw = e.rawResponse;
err = e;
}
const documentResponses = raw.status?.documentResponses ?? [];
const errors = raw.errors;
const insertedIds = [];
for (let i = 0, n = documentResponses.length; i < n; i++) {
const response = documentResponses[i];
if (response.status === "OK") {
insertedIds.push(serdes.deserialize(response._id, raw, ctx_js_1.SerDesTarget.InsertedId));
}
else if ('errorsIdx' in response) {
response.error = errors[response.errorsIdx];
delete response.errorsIdx;
}
}
return {
documentResponses,
insertedIds,
error: err,
};
};