@configurator/ravendb/dist/ServerWide/Operations/GetDatabaseRecordOperation.js

RavenDB client for Node.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.GetDatabaseRecordCommand = exports.GetDatabaseRecordOperation = void 0;
const RavenCommand_1 = require("../../Http/RavenCommand");
const TimeSeriesConfiguration_1 = require("../../Documents/Operations/TimeSeries/TimeSeriesConfiguration");
class GetDatabaseRecordOperation {
    constructor(database) {
        this._database = database;
    }
    getCommand(conventions) {
        return new GetDatabaseRecordCommand(conventions, this._database);
    }
    get resultType() {
        return "CommandResult";
    }
}
exports.GetDatabaseRecordOperation = GetDatabaseRecordOperation;
class GetDatabaseRecordCommand extends RavenCommand_1.RavenCommand {
    constructor(conventions, database) {
        super();
        this._conventions = conventions;
        this._database = database;
    }
    get isReadRequest() {
        return false;
    }
    createRequest(node) {
        const uri = node.url + "/admin/databases?name=" + this._database;
        return {
            method: "GET",
            uri
        };
    }
    async setResponseAsync(bodyStream, fromCache) {
        if (!bodyStream) {
            return null;
        }
        let body = null;
        this.result = await this._defaultPipeline(_ => body = _)
            .collectBody()
            .objectKeysTransform({
            defaultTransform: "camel",
            ignorePaths: [
                /^(indexes|sorters|autoIndexes|settings|indexesHistory|ravenConnectionStrings|sqlConnectionStrings|rollingIndexes)\.[^.]+$/i,
                /^rollingIndexes\.[^.]+\.activeDeployments\.[^.]+$/i,
                /^indexesHistory\.[^.]+\.[^.]+\.rollingDeployment\.[^.]+$/i,
                /^timeSeries\./i
            ]
        })
            .process(bodyStream);
        const dateUtil = this._conventions.dateUtil;
        if (this.result.rollingIndexes) {
            Object.values(this.result.rollingIndexes).forEach(index => {
                if (index.activeDeployments) {
                    index.activeDeployments = GetDatabaseRecordCommand.mapRollingDeployment(dateUtil, index.activeDeployments);
                }
            });
        }
        const history = this.result.indexesHistory;
        if (history) {
            for (const indexName of Object.keys(history)) {
                const indexHistory = history[indexName];
                history[indexName] = indexHistory.map(item => {
                    const { createdAt, rollingDeployment, ...otherHistoryProps } = item;
                    return {
                        ...otherHistoryProps,
                        createdAt: dateUtil.parse(createdAt),
                        rollingDeployment: GetDatabaseRecordCommand.mapRollingDeployment(dateUtil, rollingDeployment)
                    };
                });
            }
        }
        if (this.result.timeSeries) {
            this.result.timeSeries = TimeSeriesConfiguration_1.TimeSeriesConfiguration.parse(this.result.timeSeries);
        }
        return body;
    }
    static mapRollingDeployment(dateUtil, input) {
        if (!input) {
            return null;
        }
        const result = {};
        for (const tag of Object.keys(input)) {
            const deployment = input[tag];
            result[tag] = {
                state: deployment.state,
                createdAt: dateUtil.parse(deployment.createdAt),
                startedAt: dateUtil.parse(deployment.startedAt),
                finishedAt: dateUtil.parse(deployment.finishedAt),
            };
        }
        return result;
    }
}
exports.GetDatabaseRecordCommand = GetDatabaseRecordCommand;
//# sourceMappingURL=GetDatabaseRecordOperation.js.map