ravendb/dist/commonjs/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_js_1 = require("../../Http/RavenCommand.js");
const TimeSeriesConfiguration_js_1 = require("../../Documents/Operations/TimeSeries/TimeSeriesConfiguration.js");
const DateUtil_js_1 = require("../../Utility/DateUtil.js");
const ObjectUtil_js_1 = require("../../Utility/ObjectUtil.js");
class GetDatabaseRecordOperation {
    _database;
    constructor(database) {
        this._database = database;
    }
    getCommand(conventions) {
        return new GetDatabaseRecordCommand(conventions, this._database);
    }
    get resultType() {
        return "CommandResult";
    }
}
exports.GetDatabaseRecordOperation = GetDatabaseRecordOperation;
class GetDatabaseRecordCommand extends RavenCommand_js_1.RavenCommand {
    _conventions;
    _database;
    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: ObjectUtil_js_1.ObjectUtil.camel,
            ignorePaths: [
                /^(indexes|sorters|autoIndexes|settings|indexesHistory|ravenConnectionStrings|sqlConnectionStrings|rollingIndexes)\.[^.]+$/i,
                /^rollingIndexes\.[^.]+\.activeDeployments\.[^.]+$/i,
                /^indexesHistory\.[^.]+\.[^.]+\.rollingDeployment\.[^.]+$/i,
                /^timeSeries\./i
            ]
        })
            .process(bodyStream);
        if (this.result.rollingIndexes) {
            for (const index of Object.values(this.result.rollingIndexes)) {
                if (index.activeDeployments) {
                    index.activeDeployments = GetDatabaseRecordCommand.mapRollingDeployment(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_js_1.DateUtil.utc.parse(createdAt),
                        rollingDeployment: GetDatabaseRecordCommand.mapRollingDeployment(rollingDeployment)
                    };
                });
            }
        }
        if (this.result.timeSeries) {
            this.result.timeSeries = TimeSeriesConfiguration_js_1.TimeSeriesConfiguration.parse(this.result.timeSeries);
        }
        return body;
    }
    static mapRollingDeployment(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_js_1.DateUtil.utc.parse(deployment.createdAt),
                startedAt: DateUtil_js_1.DateUtil.utc.parse(deployment.startedAt),
                finishedAt: DateUtil_js_1.DateUtil.utc.parse(deployment.finishedAt),
            };
        }
        return result;
    }
}
exports.GetDatabaseRecordCommand = GetDatabaseRecordCommand;
//# sourceMappingURL=GetDatabaseRecordOperation.js.map