ravendb/dist/esm/ServerWide/Operations/CreateDatabaseOperation.js

RavenDB client for Node.js

import { RavenCommand } from "../../Http/RavenCommand.js";
import { throwError } from "../../Exceptions/index.js";
import { HeadersBuilder } from "../../Utility/HttpUtil.js";
import { HEADERS } from "../../Constants.js";
import { RaftIdGenerator } from "../../Utility/RaftIdGenerator.js";
import { TypeUtil } from "../../Utility/TypeUtil.js";
import { DatabaseRecordBuilder } from "./DatabaseRecordBuilder.js";
export class CreateDatabaseOperation {
    get resultType() {
        return "CommandResult";
    }
    _databaseRecord;
    _replicationFactor;
    constructor(databaseRecordOrBuilder, replicationFactor) {
        if (TypeUtil.isFunction(databaseRecordOrBuilder)) {
            const instance = DatabaseRecordBuilder.create();
            databaseRecordOrBuilder(instance);
            this._databaseRecord = instance.toDatabaseRecord();
            this._replicationFactor = (this._databaseRecord.topology && this._databaseRecord.topology.replicationFactor) ?? 1;
        }
        else {
            this._databaseRecord = databaseRecordOrBuilder;
            const topology = databaseRecordOrBuilder.topology;
            if (replicationFactor) {
                this._replicationFactor = replicationFactor;
            }
            else {
                if (topology) {
                    this._replicationFactor = topology.replicationFactor > 0 ? topology.replicationFactor : 1;
                }
                else {
                    this._replicationFactor = 1;
                }
            }
        }
    }
    getCommand(conventions) {
        return new CreateDatabaseCommand(conventions, this._databaseRecord, this._replicationFactor);
    }
}
export class CreateDatabaseCommand extends RavenCommand {
    _conventions;
    _databaseRecord;
    _replicationFactor;
    _dbEtag;
    _databaseName;
    constructor(conventions, databaseRecord, replicationFactor, etag) {
        super();
        this._conventions = conventions;
        this._databaseRecord = databaseRecord;
        this._replicationFactor = replicationFactor;
        this._dbEtag = etag;
        if (!databaseRecord || !databaseRecord.databaseName) {
            throwError("InvalidOperationException", "Database name is required");
        }
        this._databaseName = databaseRecord.databaseName;
    }
    createRequest(node) {
        let uri = node.url + "/admin/databases?name=" + this._databaseName;
        uri += "&replicationFactor=" + this._replicationFactor;
        const databaseDocumentJson = this._serializer.serialize(this._databaseRecord);
        return {
            uri,
            method: "PUT",
            headers: HeadersBuilder.create()
                .typeAppJson()
                .with(HEADERS.ETAG, `"${this._dbEtag}"`)
                .build(),
            body: databaseDocumentJson
        };
    }
    async setResponseAsync(bodyStream, fromCache) {
        if (!bodyStream) {
            this._throwInvalidResponse();
        }
        return this._parseResponseDefaultAsync(bodyStream);
    }
    get isReadRequest() {
        return false;
    }
    getRaftUniqueRequestId() {
        return RaftIdGenerator.newId();
    }
}
//# sourceMappingURL=CreateDatabaseOperation.js.map