couchset 0.4.1 → 0.5.0

package/dist/eventing.js

@@ -0,0 +1,822 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineEventingFunction = exports.createEventingWithManager = exports.createEventing = exports.Eventing = void 0;
+var timerStateWarning = 'Undeploying an Eventing function erases its Eventing timers and checkpoints.';
+var emptyReport = function () { return ({
+    created: [],
+    outcomes: [],
+    paused: [],
+    pruned: [],
+    removed: [],
+    requiresRecreate: [],
+    resumed: [],
+    unchanged: [],
+    updated: [],
+}); };
+var normalizeKeyspace = function (keyspace) { return ({
+    bucket: keyspace.bucket,
+    collection: keyspace.collection || '_default',
+    scope: keyspace.scope || '_default',
+}); };
+var keyspaceEquals = function (left, right) {
+    var normalizedLeft = normalizeKeyspace(left);
+    var normalizedRight = normalizeKeyspace(right);
+    return (normalizedLeft.bucket === normalizedRight.bucket &&
+        normalizedLeft.scope === normalizedRight.scope &&
+        normalizedLeft.collection === normalizedRight.collection);
+};
+var requiredKeyspace = function (keyspace, label) {
+    if (!keyspace || !keyspace.bucket) {
+        throw new Error("".concat(label, " requires a non-empty bucket"));
+    }
+};
+var stableValue = function (value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null || typeof value !== 'object') {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map(stableValue);
+    }
+    var normalized = {};
+    Object.keys(value)
+        .sort()
+        .forEach(function (key) {
+        var item = stableValue(value[key]);
+        if (item !== undefined) {
+            normalized[key] = item;
+        }
+    });
+    return normalized;
+};
+var equal = function (left, right) {
+    return JSON.stringify(stableValue(left)) === JSON.stringify(stableValue(right));
+};
+var settingsMatch = function (live, desired) {
+    var requested = desired || {};
+    var comparableLive = {};
+    Object.keys(requested).forEach(function (key) {
+        if (key !== 'deploymentStatus' && key !== 'processingStatus') {
+            comparableLive[key] = live === null || live === void 0 ? void 0 : live[key];
+        }
+    });
+    var comparableDesired = {};
+    Object.keys(requested).forEach(function (key) {
+        if (key !== 'deploymentStatus' && key !== 'processingStatus') {
+            comparableDesired[key] = requested[key];
+        }
+    });
+    return equal(comparableLive, comparableDesired);
+};
+var lifecycleFor = function (state, functionDefinition) {
+    var _a, _b;
+    var status = (state === null || state === void 0 ? void 0 : state.status) || '';
+    var deploymentStatus = (state === null || state === void 0 ? void 0 : state.deploymentStatus) ||
+        ((_a = functionDefinition.settings) === null || _a === void 0 ? void 0 : _a.deploymentStatus) ||
+        '';
+    var processingStatus = (state === null || state === void 0 ? void 0 : state.processingStatus) ||
+        ((_b = functionDefinition.settings) === null || _b === void 0 ? void 0 : _b.processingStatus) ||
+        '';
+    return {
+        deployed: status === 'deployed' || status === 'paused' || deploymentStatus === 'deployed',
+        paused: status === 'paused' || processingStatus === 'paused',
+        transitional: status === 'deploying' ||
+            status === 'undeploying' ||
+            status === 'pausing' ||
+            deploymentStatus === 'deploying' ||
+            deploymentStatus === 'undeploying',
+    };
+};
+var own = function (object, key) {
+    return Object.prototype.hasOwnProperty.call(object, key);
+};
+/**
+ * Declarative Eventing reconciler backed by the SDK 4.7 EventingFunctionManager.
+ * It only manages names starting with its namespace prefix.
+ */
+var Eventing = /** @class */ (function () {
+    function Eventing(client, options) {
+        var _this = this;
+        this.definitionsByName = new Map();
+        if (!options || !options.namespace || !options.namespace.trim()) {
+            throw new Error('Eventing requires an explicit, non-empty namespace');
+        }
+        requiredKeyspace(options.metadataKeyspace, 'Eventing metadataKeyspace');
+        if (!options.metadataKeyspace.collection ||
+            options.metadataKeyspace.collection === '_default') {
+            throw new Error('Eventing metadataKeyspace requires a dedicated non-default collection; CouchSet never uses it as application data');
+        }
+        this.client = client;
+        this.explicitManager = options.manager;
+        this.eventingMetadataKeyspace = __assign({}, options.metadataKeyspace);
+        this.lifecycleTimeoutMs = this.positiveNumber(options.lifecycleTimeoutMs, 30000);
+        this.lifecyclePollIntervalMs = this.nonNegativeNumber(options.lifecyclePollIntervalMs, 250);
+        this.prefix = "".concat(options.namespace.trim(), "__");
+        (options.definitions || options.functions || []).forEach(function (definition) {
+            return _this.register(definition);
+        });
+    }
+    Object.defineProperty(Eventing.prototype, "namespace", {
+        /** Logical namespace that owns this controller's physical functions. */
+        get: function () {
+            return this.prefix.slice(0, -2);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /** A copy of registered, code-only declarations. This performs no I/O. */
+    Eventing.prototype.definitions = function () {
+        return Array.from(this.definitionsByName.values()).map(function (definition) { return (__assign({}, definition)); });
+    };
+    /** Converts a logical declaration name into its Couchbase function name. */
+    Eventing.prototype.physicalName = function (name) {
+        this.assertLogicalName(name);
+        return "".concat(this.prefix).concat(name);
+    };
+    /** Registers or replaces an in-memory manifest declaration without I/O. */
+    Eventing.prototype.register = function (definition) {
+        this.assertDefinition(definition);
+        this.definitionsByName.set(definition.name, __assign({}, definition));
+        return definition;
+    };
+    /** Alias for register(), matching the declaration-oriented API vocabulary. */
+    Eventing.prototype.define = function (definition) {
+        return this.register(definition);
+    };
+    Eventing.prototype.apply = function (definitionOrOptions_1) {
+        return __awaiter(this, arguments, void 0, function (definitionOrOptions, possibleOptions) {
+            var dynamic, options, report, manager, live, states, statesByName, liveByName, targets, targets_1, targets_1_1, definition, e_1_1, declared_1, live_1, live_1_1, functionDefinition, e_2_1;
+            var e_1, _a, e_2, _b;
+            var _this = this;
+            if (possibleOptions === void 0) { possibleOptions = {}; }
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        dynamic = this.isDefinition(definitionOrOptions) ? definitionOrOptions : undefined;
+                        options = dynamic
+                            ? possibleOptions
+                            : definitionOrOptions || {};
+                        report = emptyReport();
+                        return [4 /*yield*/, this.manager()];
+                    case 1:
+                        manager = _c.sent();
+                        if (dynamic) {
+                            this.register(dynamic);
+                        }
+                        return [4 /*yield*/, manager.getAllFunctions()];
+                    case 2:
+                        live = _c.sent();
+                        return [4 /*yield*/, this.states(manager)];
+                    case 3:
+                        states = _c.sent();
+                        statesByName = new Map();
+                        states.forEach(function (state) { return statesByName.set(state.name, state); });
+                        liveByName = new Map();
+                        live.forEach(function (functionDefinition) {
+                            return liveByName.set(functionDefinition.name, functionDefinition);
+                        });
+                        targets = dynamic ? [dynamic] : this.definitions();
+                        _c.label = 4;
+                    case 4:
+                        _c.trys.push([4, 9, 10, 11]);
+                        targets_1 = __values(targets), targets_1_1 = targets_1.next();
+                        _c.label = 5;
+                    case 5:
+                        if (!!targets_1_1.done) return [3 /*break*/, 8];
+                        definition = targets_1_1.value;
+                        return [4 /*yield*/, this.reconcile(manager, definition, liveByName.get(this.physicalName(definition.name)), statesByName.get(this.physicalName(definition.name)), options, report)];
+                    case 6:
+                        _c.sent();
+                        _c.label = 7;
+                    case 7:
+                        targets_1_1 = targets_1.next();
+                        return [3 /*break*/, 5];
+                    case 8: return [3 /*break*/, 11];
+                    case 9:
+                        e_1_1 = _c.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 11];
+                    case 10:
+                        try {
+                            if (targets_1_1 && !targets_1_1.done && (_a = targets_1.return)) _a.call(targets_1);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                        return [7 /*endfinally*/];
+                    case 11:
+                        if (!!dynamic) return [3 /*break*/, 19];
+                        declared_1 = new Set();
+                        targets.forEach(function (definition) { return declared_1.add(_this.physicalName(definition.name)); });
+                        _c.label = 12;
+                    case 12:
+                        _c.trys.push([12, 17, 18, 19]);
+                        live_1 = __values(live), live_1_1 = live_1.next();
+                        _c.label = 13;
+                    case 13:
+                        if (!!live_1_1.done) return [3 /*break*/, 16];
+                        functionDefinition = live_1_1.value;
+                        if (!(this.owns(functionDefinition.name) && !declared_1.has(functionDefinition.name))) return [3 /*break*/, 15];
+                        return [4 /*yield*/, this.prune(manager, functionDefinition, statesByName.get(functionDefinition.name), report)];
+                    case 14:
+                        _c.sent();
+                        _c.label = 15;
+                    case 15:
+                        live_1_1 = live_1.next();
+                        return [3 /*break*/, 13];
+                    case 16: return [3 /*break*/, 19];
+                    case 17:
+                        e_2_1 = _c.sent();
+                        e_2 = { error: e_2_1 };
+                        return [3 /*break*/, 19];
+                    case 18:
+                        try {
+                            if (live_1_1 && !live_1_1.done && (_b = live_1.return)) _b.call(live_1);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                        return [7 /*endfinally*/];
+                    case 19: return [2 /*return*/, report];
+                }
+            });
+        });
+    };
+    /** Temporarily disables one namespace-owned Eventing function. */
+    Eventing.prototype.pause = function (name) {
+        return __awaiter(this, void 0, void 0, function () {
+            var report, physicalName, manager, live, current, states, state, lifecycle;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        report = emptyReport();
+                        physicalName = this.physicalName(name);
+                        return [4 /*yield*/, this.manager()];
+                    case 1:
+                        manager = _a.sent();
+                        return [4 /*yield*/, manager.getAllFunctions()];
+                    case 2:
+                        live = _a.sent();
+                        current = live.filter(function (functionDefinition) { return functionDefinition.name === physicalName; })[0];
+                        if (!current) {
+                            this.record(report, this.outcome('unchanged', name, ['unchanged'], 'No namespace-owned Eventing function exists with this name.'));
+                            return [2 /*return*/, report];
+                        }
+                        return [4 /*yield*/, this.states(manager)];
+                    case 3:
+                        states = _a.sent();
+                        state = states.filter(function (item) { return item.name === physicalName; })[0];
+                        return [4 /*yield*/, this.stableLifecycle(manager, physicalName, current, state)];
+                    case 4:
+                        lifecycle = _a.sent();
+                        if (!lifecycle.deployed || lifecycle.paused) {
+                            this.record(report, this.outcome('unchanged', name, ['unchanged']));
+                            return [2 /*return*/, report];
+                        }
+                        return [4 /*yield*/, manager.pauseFunction(physicalName)];
+                    case 5:
+                        _a.sent();
+                        return [4 /*yield*/, this.waitForLifecycle(manager, physicalName, 'paused')];
+                    case 6:
+                        _a.sent();
+                        this.record(report, this.outcome('paused', name, ['paused']));
+                        return [2 /*return*/, report];
+                }
+            });
+        });
+    };
+    /**
+     * Intentionally undeploys then deletes one namespace-owned function.
+     * Undeployment erases Couchbase Eventing timers and checkpoints.
+     */
+    Eventing.prototype.remove = function (name) {
+        return __awaiter(this, void 0, void 0, function () {
+            var report, physicalName, manager, live, current, states, state, lifecycle;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        report = emptyReport();
+                        physicalName = this.physicalName(name);
+                        return [4 /*yield*/, this.manager()];
+                    case 1:
+                        manager = _a.sent();
+                        return [4 /*yield*/, manager.getAllFunctions()];
+                    case 2:
+                        live = _a.sent();
+                        current = live.filter(function (functionDefinition) { return functionDefinition.name === physicalName; })[0];
+                        if (!current) {
+                            this.record(report, this.outcome('unchanged', name, ['unchanged'], 'No namespace-owned Eventing function exists with this name.'));
+                            return [2 /*return*/, report];
+                        }
+                        return [4 /*yield*/, this.states(manager)];
+                    case 3:
+                        states = _a.sent();
+                        state = states.filter(function (item) { return item.name === physicalName; })[0];
+                        return [4 /*yield*/, this.stableLifecycle(manager, physicalName, current, state)];
+                    case 4:
+                        lifecycle = _a.sent();
+                        if (!lifecycle.deployed) return [3 /*break*/, 7];
+                        return [4 /*yield*/, manager.undeployFunction(physicalName)];
+                    case 5:
+                        _a.sent();
+                        return [4 /*yield*/, this.waitForLifecycle(manager, physicalName, 'undeployed')];
+                    case 6:
+                        _a.sent();
+                        _a.label = 7;
+                    case 7: return [4 /*yield*/, manager.dropFunction(physicalName)];
+                    case 8:
+                        _a.sent();
+                        this.definitionsByName.delete(name);
+                        this.record(report, this.outcome('removed', name, ['removed'], timerStateWarning, lifecycle.deployed));
+                        return [2 /*return*/, report];
+                }
+            });
+        });
+    };
+    Eventing.prototype.reconcile = function (manager, definition, current, state, options, report) {
+        return __awaiter(this, void 0, void 0, function () {
+            var physicalName, desired, lifecycle, keyspaceChanged, actions;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        physicalName = this.physicalName(definition.name);
+                        desired = this.sdkDefinition(definition);
+                        if (!!current) return [3 /*break*/, 4];
+                        return [4 /*yield*/, manager.upsertFunction(desired)];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, manager.deployFunction(physicalName)];
+                    case 2:
+                        _a.sent();
+                        return [4 /*yield*/, this.waitForLifecycle(manager, physicalName, 'deployed')];
+                    case 3:
+                        _a.sent();
+                        this.record(report, this.outcome('created', definition.name, ['created']));
+                        return [2 /*return*/];
+                    case 4: return [4 /*yield*/, this.stableLifecycle(manager, physicalName, current, state)];
+                    case 5:
+                        lifecycle = _a.sent();
+                        keyspaceChanged = !keyspaceEquals(current.sourceKeyspace, desired.sourceKeyspace) ||
+                            !keyspaceEquals(current.metadataKeyspace, desired.metadataKeyspace);
+                        if (!keyspaceChanged) return [3 /*break*/, 12];
+                        if (!options.allowRecreate) {
+                            this.record(report, this.outcome('requires-recreate', definition.name, ['requires-recreate'], "".concat(timerStateWarning, " Re-run apply with {allowRecreate: true} to permit this keyspace change.")));
+                            return [2 /*return*/];
+                        }
+                        if (!lifecycle.deployed) return [3 /*break*/, 8];
+                        return [4 /*yield*/, manager.undeployFunction(physicalName)];
+                    case 6:
+                        _a.sent();
+                        return [4 /*yield*/, this.waitForLifecycle(manager, physicalName, 'undeployed')];
+                    case 7:
+                        _a.sent();
+                        _a.label = 8;
+                    case 8: return [4 /*yield*/, manager.upsertFunction(desired)];
+                    case 9:
+                        _a.sent();
+                        return [4 /*yield*/, manager.deployFunction(physicalName)];
+                    case 10:
+                        _a.sent();
+                        return [4 /*yield*/, this.waitForLifecycle(manager, physicalName, 'deployed')];
+                    case 11:
+                        _a.sent();
+                        this.record(report, this.outcome('updated', definition.name, ['updated'], timerStateWarning, lifecycle.deployed));
+                        return [2 /*return*/];
+                    case 12:
+                        if (!this.matches(current, desired, definition)) return [3 /*break*/, 20];
+                        if (!lifecycle.paused) return [3 /*break*/, 15];
+                        return [4 /*yield*/, manager.resumeFunction(physicalName)];
+                    case 13:
+                        _a.sent();
+                        return [4 /*yield*/, this.waitForLifecycle(manager, physicalName, 'deployed')];
+                    case 14:
+                        _a.sent();
+                        this.record(report, this.outcome('resumed', definition.name, ['resumed']));
+                        return [3 /*break*/, 19];
+                    case 15:
+                        if (!!lifecycle.deployed) return [3 /*break*/, 18];
+                        return [4 /*yield*/, manager.deployFunction(physicalName)];
+                    case 16:
+                        _a.sent();
+                        return [4 /*yield*/, this.waitForLifecycle(manager, physicalName, 'deployed')];
+                    case 17:
+                        _a.sent();
+                        this.record(report, this.outcome('resumed', definition.name, ['resumed']));
+                        return [3 /*break*/, 19];
+                    case 18:
+                        this.record(report, this.outcome('unchanged', definition.name, ['unchanged']));
+                        _a.label = 19;
+                    case 19: return [2 /*return*/];
+                    case 20:
+                        actions = [];
+                        if (!(lifecycle.deployed && !lifecycle.paused)) return [3 /*break*/, 23];
+                        return [4 /*yield*/, manager.pauseFunction(physicalName)];
+                    case 21:
+                        _a.sent();
+                        return [4 /*yield*/, this.waitForLifecycle(manager, physicalName, 'paused')];
+                    case 22:
+                        _a.sent();
+                        actions.push('paused');
+                        _a.label = 23;
+                    case 23: return [4 /*yield*/, manager.upsertFunction(desired)];
+                    case 24:
+                        _a.sent();
+                        actions.push('updated');
+                        return [4 /*yield*/, this.activateAfterUpsert(manager, physicalName, desired, actions)];
+                    case 25:
+                        _a.sent();
+                        this.record(report, this.outcome('updated', definition.name, actions));
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Eventing.prototype.prune = function (manager, functionDefinition, state, report) {
+        return __awaiter(this, void 0, void 0, function () {
+            var lifecycle;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.stableLifecycle(manager, functionDefinition.name, functionDefinition, state)];
+                    case 1:
+                        lifecycle = _a.sent();
+                        if (!lifecycle.deployed) return [3 /*break*/, 4];
+                        return [4 /*yield*/, manager.undeployFunction(functionDefinition.name)];
+                    case 2:
+                        _a.sent();
+                        return [4 /*yield*/, this.waitForLifecycle(manager, functionDefinition.name, 'undeployed')];
+                    case 3:
+                        _a.sent();
+                        _a.label = 4;
+                    case 4: return [4 /*yield*/, manager.dropFunction(functionDefinition.name)];
+                    case 5:
+                        _a.sent();
+                        this.record(report, this.outcome('pruned', this.logicalName(functionDefinition.name), ['pruned'], timerStateWarning, lifecycle.deployed));
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Eventing.prototype.matches = function (current, desired, definition) {
+        return (current.code === desired.code &&
+            (definition.enforceSchema === undefined ||
+                current.enforceSchema === desired.enforceSchema) &&
+            equal(current.bucketBindings || [], desired.bucketBindings || []) &&
+            equal(current.urlBindings || [], desired.urlBindings || []) &&
+            equal(current.constantBindings || [], desired.constantBindings || []) &&
+            settingsMatch(current.settings, definition.settings));
+    };
+    Eventing.prototype.sdkDefinition = function (definition) {
+        var metadataKeyspace = normalizeKeyspace(this.metadataKeyspace());
+        var sourceKeyspace = normalizeKeyspace(definition.sourceKeyspace);
+        var settings = __assign({}, (definition.settings || {}));
+        // Lifecycle is controlled through manager methods, never through an upsert payload.
+        delete settings.deploymentStatus;
+        delete settings.processingStatus;
+        return {
+            bucketBindings: definition.bucketBindings || [],
+            code: definition.code,
+            constantBindings: definition.constantBindings || [],
+            enforceSchema: definition.enforceSchema,
+            metadataKeyspace: metadataKeyspace,
+            name: this.physicalName(definition.name),
+            settings: settings,
+            sourceKeyspace: sourceKeyspace,
+            urlBindings: definition.urlBindings || [],
+        };
+    };
+    Eventing.prototype.metadataKeyspace = function () {
+        // The keyspace has already been validated in the constructor. Keeping it
+        // behind this helper prevents accidental exposure as a CouchSet collection.
+        return this.eventingMetadataKeyspace;
+    };
+    Eventing.prototype.manager = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var cluster;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.explicitManager) {
+                            return [2 /*return*/, this.explicitManager];
+                        }
+                        if (!this.client) {
+                            throw new Error('Eventing requires a CouchSet client or an explicit EventingFunctionManager');
+                        }
+                        return [4 /*yield*/, this.client.ready()];
+                    case 1:
+                        _a.sent();
+                        cluster = this.client.getConnection().cluster;
+                        if (!cluster || typeof cluster.eventingFunctions !== 'function') {
+                            throw new Error('The connected Couchbase SDK does not expose EventingFunctionManager');
+                        }
+                        return [2 /*return*/, cluster.eventingFunctions()];
+                }
+            });
+        });
+    };
+    Eventing.prototype.states = function (manager) {
+        return __awaiter(this, void 0, void 0, function () {
+            var result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, manager.functionsStatus()];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, result.functions || []];
+                }
+            });
+        });
+    };
+    /**
+     * Management requests acknowledge receipt, not necessarily completion. Do
+     * not issue the next incompatible Eventing operation until status confirms
+     * that Couchbase has converged.
+     */
+    Eventing.prototype.waitForLifecycle = function (manager, physicalName, expected) {
+        return __awaiter(this, void 0, void 0, function () {
+            var deadline, state, lifecycle, reached;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        deadline = Date.now() + this.lifecycleTimeoutMs;
+                        _a.label = 1;
+                    case 1:
+                        if (!true) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.states(manager)];
+                    case 2:
+                        state = (_a.sent()).filter(function (item) { return item.name === physicalName; })[0];
+                        lifecycle = lifecycleFor(state, { settings: {} });
+                        reached = !!state &&
+                            !lifecycle.transitional &&
+                            ((expected === 'deployed' && lifecycle.deployed && !lifecycle.paused) ||
+                                (expected === 'paused' && lifecycle.deployed && lifecycle.paused) ||
+                                (expected === 'undeployed' && !lifecycle.deployed));
+                        if (reached) {
+                            return [2 /*return*/];
+                        }
+                        if (Date.now() >= deadline) {
+                            throw new Error("Timed out waiting for Eventing function ".concat(physicalName, " to become ").concat(expected));
+                        }
+                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, _this.lifecyclePollIntervalMs); })];
+                    case 3:
+                        _a.sent();
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Couchbase Server may turn a paused function into an undeployed function
+     * when upsert persists new code/settings/bindings. Inspect that post-upsert
+     * state rather than assuming resume is legal; deploy is the compatible
+     * activation operation in that case.
+     */
+    Eventing.prototype.activateAfterUpsert = function (manager, physicalName, functionDefinition, actions) {
+        return __awaiter(this, void 0, void 0, function () {
+            var lifecycle;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.waitForStableLifecycle(manager, physicalName, functionDefinition)];
+                    case 1:
+                        lifecycle = _a.sent();
+                        if (!(lifecycle.deployed && lifecycle.paused)) return [3 /*break*/, 4];
+                        return [4 /*yield*/, manager.resumeFunction(physicalName)];
+                    case 2:
+                        _a.sent();
+                        return [4 /*yield*/, this.waitForLifecycle(manager, physicalName, 'deployed')];
+                    case 3:
+                        _a.sent();
+                        actions.push('resumed');
+                        return [3 /*break*/, 7];
+                    case 4:
+                        if (!!lifecycle.deployed) return [3 /*break*/, 7];
+                        return [4 /*yield*/, manager.deployFunction(physicalName)];
+                    case 5:
+                        _a.sent();
+                        return [4 /*yield*/, this.waitForLifecycle(manager, physicalName, 'deployed')];
+                    case 6:
+                        _a.sent();
+                        actions.push('resumed');
+                        _a.label = 7;
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * A live function with no status row is unknown, not safely undeployed.
+     * Poll for a positive row; a known transitional row remains an immediate
+     * blocker so callers do not race an operator's in-progress lifecycle call.
+     */
+    Eventing.prototype.stableLifecycle = function (manager, physicalName, functionDefinition, initialState) {
+        return __awaiter(this, void 0, void 0, function () {
+            var lifecycle, deadline, state, lifecycle;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (initialState) {
+                            lifecycle = lifecycleFor(initialState, functionDefinition);
+                            this.assertStable(physicalName, lifecycle);
+                            return [2 /*return*/, lifecycle];
+                        }
+                        deadline = Date.now() + this.lifecycleTimeoutMs;
+                        _a.label = 1;
+                    case 1:
+                        if (!true) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.states(manager)];
+                    case 2:
+                        state = (_a.sent()).filter(function (item) { return item.name === physicalName; })[0];
+                        if (state) {
+                            lifecycle = lifecycleFor(state, functionDefinition);
+                            this.assertStable(physicalName, lifecycle);
+                            return [2 /*return*/, lifecycle];
+                        }
+                        if (Date.now() >= deadline) {
+                            throw new Error("Timed out waiting for Eventing status for function ".concat(physicalName));
+                        }
+                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, _this.lifecyclePollIntervalMs); })];
+                    case 3:
+                        _a.sent();
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /** Waits for a stable state caused by this controller's own upsert call. */
+    Eventing.prototype.waitForStableLifecycle = function (manager, physicalName, functionDefinition) {
+        return __awaiter(this, void 0, void 0, function () {
+            var deadline, state, lifecycle;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        deadline = Date.now() + this.lifecycleTimeoutMs;
+                        _a.label = 1;
+                    case 1:
+                        if (!true) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.states(manager)];
+                    case 2:
+                        state = (_a.sent()).filter(function (item) { return item.name === physicalName; })[0];
+                        if (state) {
+                            lifecycle = lifecycleFor(state, functionDefinition);
+                            if (!lifecycle.transitional) {
+                                return [2 /*return*/, lifecycle];
+                            }
+                        }
+                        if (Date.now() >= deadline) {
+                            throw new Error("Timed out waiting for Eventing function ".concat(physicalName, " to settle after upsert"));
+                        }
+                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, _this.lifecyclePollIntervalMs); })];
+                    case 3:
+                        _a.sent();
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Eventing.prototype.record = function (report, outcome) {
+        report.outcomes.push(outcome);
+        var actions = outcome.actions.length ? outcome.actions : [outcome.action];
+        actions.forEach(function (action) {
+            var list = action === 'requires-recreate' ? report.requiresRecreate : report[action];
+            if (list && list.indexOf(outcome) === -1) {
+                list.push(outcome);
+            }
+        });
+    };
+    Eventing.prototype.outcome = function (action, name, actions, message, timerStateLost) {
+        return {
+            action: action,
+            actions: actions,
+            message: message,
+            name: name,
+            physicalName: this.physicalName(name),
+            timerStateLost: timerStateLost,
+        };
+    };
+    Eventing.prototype.owns = function (name) {
+        return typeof name === 'string' && name.indexOf(this.prefix) === 0;
+    };
+    Eventing.prototype.logicalName = function (physicalName) {
+        if (!this.owns(physicalName)) {
+            throw new Error("Refusing to manage Eventing function outside namespace ".concat(this.namespace));
+        }
+        return physicalName.slice(this.prefix.length);
+    };
+    Eventing.prototype.assertDefinition = function (definition) {
+        if (!definition || !definition.name || !definition.name.trim()) {
+            throw new Error('Eventing definitions require a non-empty logical name');
+        }
+        if (!definition.code || typeof definition.code !== 'string') {
+            throw new Error("Eventing definition ".concat(definition.name, " requires handler code"));
+        }
+        requiredKeyspace(definition.sourceKeyspace, "Eventing definition ".concat(definition.name, " sourceKeyspace"));
+        if (keyspaceEquals(definition.sourceKeyspace, this.metadataKeyspace())) {
+            throw new Error("Eventing definition ".concat(definition.name, " must use a dedicated metadata keyspace distinct from its source keyspace"));
+        }
+    };
+    Eventing.prototype.assertLogicalName = function (name) {
+        if (!name || !name.trim()) {
+            throw new Error('Eventing requires a non-empty logical function name');
+        }
+        if (name.indexOf(this.prefix) === 0) {
+            throw new Error('Pass Eventing logical names, not physical namespace-prefixed names');
+        }
+    };
+    Eventing.prototype.assertStable = function (physicalName, lifecycle) {
+        if (lifecycle.transitional) {
+            throw new Error("Eventing function ".concat(physicalName, " is transitioning; wait for Couchbase to settle before reconciling it"));
+        }
+    };
+    Eventing.prototype.isDefinition = function (value) {
+        return !!value && own(value, 'name') && own(value, 'code') && own(value, 'sourceKeyspace');
+    };
+    Eventing.prototype.positiveNumber = function (value, fallback) {
+        return typeof value === 'number' && value > 0 ? value : fallback;
+    };
+    Eventing.prototype.nonNegativeNumber = function (value, fallback) {
+        return typeof value === 'number' && value >= 0 ? value : fallback;
+    };
+    return Eventing;
+}());
+exports.Eventing = Eventing;
+/**
+ * Construct an Eventing control plane from a CouchSet client. The client is
+ * used only to obtain the SDK EventingFunctionManager after `ready()`.
+ */
+var createEventing = function (client, options) {
+    return new Eventing(client, options);
+};
+exports.createEventing = createEventing;
+/** Construct an Eventing control plane around an application-owned SDK manager. */
+var createEventingWithManager = function (options) {
+    if (!options.manager) {
+        throw new Error('createEventingWithManager requires EventingOptions.manager');
+    }
+    return new Eventing(undefined, options);
+};
+exports.createEventingWithManager = createEventingWithManager;
+/** A small helper that makes Eventing definitions read as manifest declarations. */
+var defineEventingFunction = function (definition) { return (__assign({}, definition)); };
+exports.defineEventingFunction = defineEventingFunction;
+//# sourceMappingURL=eventing.js.map