@configurator/ravendb
Version:
RavenDB client for Node.js
230 lines • 11.6 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.DocumentSubscriptions = void 0;
const TypeUtil_1 = require("../../Utility/TypeUtil");
const Exceptions_1 = require("../../Exceptions");
const CreateSubscriptionCommand_1 = require("../Commands/CreateSubscriptionCommand");
const SubscriptionWorker_1 = require("./SubscriptionWorker");
const DeleteSubscriptionCommand_1 = require("../Commands/DeleteSubscriptionCommand");
const StringUtil_1 = require("../../Utility/StringUtil");
const GetSubscriptionStateCommand_1 = require("../Commands/GetSubscriptionStateCommand");
const DropSubscriptionConnectionCommand_1 = require("../Commands/DropSubscriptionConnectionCommand");
const GetSubscriptionsCommand_1 = require("../Commands/GetSubscriptionsCommand");
const ToggleOngoingTaskStateOperation_1 = require("../Operations/OngoingTasks/ToggleOngoingTaskStateOperation");
const SubscriptionIncludeBuilder_1 = require("../Session/Loaders/SubscriptionIncludeBuilder");
const os = require("os");
const IncludesUtil_1 = require("../Session/IncludesUtil");
const StringBuilder_1 = require("../../Utility/StringBuilder");
const UpdateSubscriptionCommand_1 = require("../Commands/UpdateSubscriptionCommand");
const CounterIncludesToken_1 = require("../Session/Tokens/CounterIncludesToken");
const TimeSeriesIncludesToken_1 = require("../Session/Tokens/TimeSeriesIncludesToken");
const QueryToken_1 = require("../Session/Tokens/QueryToken");
class DocumentSubscriptions {
constructor(store) {
this._subscriptions = new Map();
this._store = store;
}
async create(optionsOrDocumentType, database) {
let options = null;
if (TypeUtil_1.TypeUtil.isDocumentType(optionsOrDocumentType)) {
options = {
documentType: optionsOrDocumentType
};
return this.create(this._ensureCriteria(options, false), database);
}
else {
options = this._ensureCriteria(optionsOrDocumentType, false);
}
if (!options) {
(0, Exceptions_1.throwError)("InvalidArgumentException", "Cannot create a subscription if options are null");
}
if (!options.query) {
(0, Exceptions_1.throwError)("InvalidArgumentException", "Cannot create a subscription if the script is null");
}
const requestExecutor = this._store.getRequestExecutor(this._store.getEffectiveDatabase(database));
const command = new CreateSubscriptionCommand_1.CreateSubscriptionCommand(options);
await requestExecutor.execute(command);
return command.result.name;
}
createForRevisions(options, database) {
options = options || {};
return this.create(this._ensureCriteria(options, true), database);
}
_ensureCriteria(criteria, revisions) {
if (!criteria) {
criteria = {};
}
const objectDescriptor = this._store.conventions.getJsTypeByDocumentType(criteria.documentType);
const collectionName = this._store.conventions.getCollectionNameForType(objectDescriptor);
let queryBuilder;
if (criteria.query) {
queryBuilder = new StringBuilder_1.StringBuilder(criteria.query);
}
else {
queryBuilder = new StringBuilder_1.StringBuilder("from '");
StringUtil_1.StringUtil.escapeString(queryBuilder, collectionName);
queryBuilder.append("'");
if (revisions) {
queryBuilder.append(" (Revisions = true)");
}
queryBuilder.append(" as doc");
}
if (criteria.includes) {
const builder = new SubscriptionIncludeBuilder_1.SubscriptionIncludeBuilder(this._store.conventions);
criteria.includes(builder);
let numberOfIncludesAdded = 0;
if (builder.documentsToInclude && builder.documentsToInclude.size) {
queryBuilder.append(os.EOL + "include ");
for (const inc of builder.documentsToInclude) {
const include = "doc." + inc;
if (numberOfIncludesAdded > 0) {
queryBuilder.append(",");
}
let escapedInclude;
if (IncludesUtil_1.IncludesUtil.requiresQuotes(include, x => escapedInclude = x)) {
queryBuilder
.append("'")
.append(escapedInclude)
.append("'");
}
else {
queryBuilder
.append(QueryToken_1.QueryToken.isKeyword(include) ? "'" + include + "'" : include);
}
numberOfIncludesAdded++;
}
}
if (builder.isAllCounters) {
if (!numberOfIncludesAdded) {
queryBuilder
.append(os.EOL)
.append("include ");
}
const token = CounterIncludesToken_1.CounterIncludesToken.all("");
token.writeTo(queryBuilder);
numberOfIncludesAdded++;
}
else if (builder.countersToInclude && builder.countersToInclude.size) {
if (!numberOfIncludesAdded) {
queryBuilder
.append(os.EOL)
.append("include ");
}
for (const counterName of builder.countersToInclude) {
if (numberOfIncludesAdded > 0) {
queryBuilder.append(",");
}
const token = CounterIncludesToken_1.CounterIncludesToken.create("", counterName);
token.writeTo(queryBuilder);
numberOfIncludesAdded++;
}
}
if (builder.timeSeriesToInclude) {
for (const timeSeriesRange of builder.timeSeriesToInclude) {
if (numberOfIncludesAdded === 0) {
queryBuilder
.append(os.EOL)
.append("include ");
}
if (numberOfIncludesAdded > 0) {
queryBuilder.append(",");
}
const token = TimeSeriesIncludesToken_1.TimeSeriesIncludesToken.create("", timeSeriesRange);
token.writeTo(queryBuilder);
numberOfIncludesAdded++;
}
}
}
criteria.query = queryBuilder.toString();
return criteria;
}
getSubscriptionWorker(optionsOrSubscriptionName, database) {
if (TypeUtil_1.TypeUtil.isString(optionsOrSubscriptionName)) {
return this.getSubscriptionWorker({
subscriptionName: optionsOrSubscriptionName
}, database);
}
const options = optionsOrSubscriptionName;
this._store.assertInitialized();
if (!options) {
(0, Exceptions_1.throwError)("InvalidArgumentException", "Cannot open a subscription if options are null");
}
const subscription = new SubscriptionWorker_1.SubscriptionWorker(options, false, this._store, database);
subscription.on("end", () => this._subscriptions.delete(subscription));
this._subscriptions.set(subscription, true);
return subscription;
}
getSubscriptionWorkerForRevisions(optionsOrSubscriptionName, database) {
if (TypeUtil_1.TypeUtil.isString(optionsOrSubscriptionName)) {
return this.getSubscriptionWorkerForRevisions({
subscriptionName: optionsOrSubscriptionName,
}, database);
}
const options = optionsOrSubscriptionName;
const subscription = new SubscriptionWorker_1.SubscriptionWorker(options, true, this._store, database);
subscription.on("end", () => this._subscriptions.delete(subscription));
this._subscriptions.set(subscription, true);
return subscription;
}
async getSubscriptions(start, take, database) {
const requestExecutor = this._store.getRequestExecutor(this._store.getEffectiveDatabase(database));
const command = new GetSubscriptionsCommand_1.GetSubscriptionsCommand(start, take);
await requestExecutor.execute(command);
return command.result;
}
async delete(name, database) {
const requestExecutor = this._store.getRequestExecutor(this._store.getEffectiveDatabase(database));
const command = new DeleteSubscriptionCommand_1.DeleteSubscriptionCommand(name);
return requestExecutor.execute(command);
}
async getSubscriptionState(subscriptionName, database) {
if (StringUtil_1.StringUtil.isNullOrEmpty(subscriptionName)) {
(0, Exceptions_1.throwError)("InvalidArgumentException", "SubscriptionName cannot be null");
}
const requestExecutor = this._store.getRequestExecutor(this._store.getEffectiveDatabase(database));
const command = new GetSubscriptionStateCommand_1.GetSubscriptionStateCommand(subscriptionName);
await requestExecutor.execute(command);
return command.result;
}
dispose() {
if (!this._subscriptions.size) {
return;
}
this._subscriptions.forEach(((value, key) => key.dispose()));
}
async dropSubscriptionWorker(worker, database = null) {
database ?? (database = this._store.database);
const requestExecutor = this._store.getRequestExecutor(database);
const command = new DropSubscriptionConnectionCommand_1.DropSubscriptionConnectionCommand(worker.subscriptionName, worker.getWorkerId());
await requestExecutor.execute(command);
}
async dropConnection(name, database) {
const requestExecutor = this._store.getRequestExecutor(this._store.getEffectiveDatabase(database));
const command = new DropSubscriptionConnectionCommand_1.DropSubscriptionConnectionCommand(name);
return requestExecutor.execute(command);
}
async enable(name, database) {
const operation = new ToggleOngoingTaskStateOperation_1.ToggleOngoingTaskStateOperation(name, "Subscription", false);
await this._store.maintenance.forDatabase(this._store.getEffectiveDatabase(database))
.send(operation);
}
async disable(name, database) {
const operation = new ToggleOngoingTaskStateOperation_1.ToggleOngoingTaskStateOperation(name, "Subscription", true);
await this._store.maintenance.forDatabase(this._store.getEffectiveDatabase(database))
.send(operation);
}
async update(options, database) {
if (!options) {
(0, Exceptions_1.throwError)("InvalidArgumentException", "Cannot update a subscription if options is null");
}
if (StringUtil_1.StringUtil.isNullOrEmpty(options.name) && !options.id) {
(0, Exceptions_1.throwError)("InvalidArgumentException", "Cannot update a subscription if both options.name and options.if are null");
}
const requestExecutor = this._store.getRequestExecutor(database);
const command = new UpdateSubscriptionCommand_1.UpdateSubscriptionCommand(options);
await requestExecutor.execute(command, null);
return command.result.name;
}
}
exports.DocumentSubscriptions = DocumentSubscriptions;
//# sourceMappingURL=DocumentSubscriptions.js.map