couchset 0.3.0 → 0.4.1

package/dist/next.js

@@ -0,0 +1,1190 @@
+"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.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCouchsetClient = exports.createCouchsetTestFixture = exports.CouchsetTransaction = exports.TransactionModel = exports.CouchsetClient = exports.defineModel = exports.dateCodec = void 0;
+var couchbase_1 = __importDefault(require("./couchbase"));
+var model_1 = require("./model");
+var indexes_1 = require("./model/indexes");
+var keyspace_1 = require("./model/keyspace");
+var builders_1 = require("./query/helpers/builders");
+var uuid_1 = require("./uuid");
+/** A JSON-friendly Date codec for models declared with defineModel. */
+exports.dateCodec = {
+    fromDatabase: function (value) { return new Date(value); },
+    toDatabase: function (value) { return value.toISOString(); },
+};
+var defineModel = function (definition) {
+    if (!definition || !definition.name) {
+        throw new Error('defineModel requires a non-empty name');
+    }
+    return __assign({}, definition);
+};
+exports.defineModel = defineModel;
+var defaultSettings = function (options) { return ({
+    bucketName: options.bucketName || 'default',
+    connectionString: options.connectionString || 'couchbase://localhost',
+    password: options.password || '',
+    username: options.username || '',
+    proxy: options.proxy,
+}); };
+var errorText = function (error) { return "".concat((error === null || error === void 0 ? void 0 : error.name) || '', " ").concat((error === null || error === void 0 ? void 0 : error.message) || error || ''); };
+var isAlreadyExists = function (error) {
+    return /already exists|exists|ScopeExists|CollectionExists/i.test(errorText(error));
+};
+var isNotFound = function (error) { return /not found|not exist/i.test(errorText(error)); };
+var provisionError = function (operation, target, error) {
+    var message = errorText(error);
+    var privilege = /access|permission|authoriz|privilege|forbidden/i.test(message)
+        ? ' This operation requires Couchbase Manage Scopes privileges on the bucket.'
+        : '';
+    var wrapped = new Error("CouchSet could not ".concat(operation, " ").concat(target, ".").concat(privilege, " ").concat(message).trim());
+    wrapped.cause = error;
+    return wrapped;
+};
+var delay = function (milliseconds) {
+    return new Promise(function (resolve) { return setTimeout(resolve, milliseconds); });
+};
+var DirectConnection = /** @class */ (function () {
+    function DirectConnection(settings, dependencies) {
+        this.settings = settings;
+        this.dependencies = dependencies;
+        this.cluster = dependencies.cluster;
+        this.bucket = dependencies.bucket;
+        if (this.cluster && !this.bucket) {
+            this.bucket = this.cluster.bucket(settings.bucketName);
+        }
+    }
+    DirectConnection.prototype.getBucket = function () {
+        return this.settings.bucketName;
+    };
+    DirectConnection.prototype.getCollection = function (scopeName, collectionName) {
+        if (!this.bucket) {
+            throw new Error('CouchSet client is not connected; call client.ready() first');
+        }
+        if (!scopeName && !collectionName) {
+            return this.bucket.defaultCollection();
+        }
+        return this.bucket.scope(scopeName || '_default').collection(collectionName || '_default');
+    };
+    DirectConnection.prototype.isConnected = function () {
+        return !!this.cluster && !!this.bucket;
+    };
+    DirectConnection.prototype.ready = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var connect, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (this.isConnected()) {
+                            return [2 /*return*/, this];
+                        }
+                        if (!this.connectPromise) {
+                            connect = this.dependencies.connect ||
+                                (function (settings) {
+                                    return couchbase_1.default.connect(settings.connectionString, {
+                                        password: settings.password,
+                                        proxy: settings.proxy,
+                                        username: settings.username,
+                                    });
+                                });
+                            this.connectPromise = connect(this.settings);
+                        }
+                        _a = this;
+                        return [4 /*yield*/, this.connectPromise];
+                    case 1:
+                        _a.cluster = _b.sent();
+                        this.bucket = this.cluster.bucket(this.settings.bucketName);
+                        return [2 /*return*/, this];
+                }
+            });
+        });
+    };
+    DirectConnection.prototype.shouldReconnect = function () {
+        return false;
+    };
+    DirectConnection.prototype.markDisconnected = function () {
+        // A client-owned connection never retries an arbitrary write operation.
+    };
+    DirectConnection.prototype.shutdown = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(this.cluster && typeof this.cluster.close === 'function')) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.cluster.close()];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        this.cluster = undefined;
+                        this.bucket = undefined;
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return DirectConnection;
+}());
+/**
+ * A client owns its model-definition registry and connection. It intentionally
+ * does not alter the legacy singleton or register models globally.
+ */
+var CouchsetClient = /** @class */ (function () {
+    function CouchsetClient(options) {
+        if (options === void 0) { options = {}; }
+        var _this = this;
+        this.registered = new Map();
+        this.settings = defaultSettings(options);
+        var dependencies = options.dependencies || {};
+        if (dependencies.connection) {
+            var bucketName = dependencies.connection.getBucket();
+            if (!bucketName) {
+                throw new Error('Injected CouchSet connections must expose a bucket name');
+            }
+            if (options.bucketName && options.bucketName !== bucketName) {
+                throw new Error("Injected CouchSet connection targets ".concat(bucketName, ", not requested bucket ").concat(options.bucketName));
+            }
+            this.settings.bucketName = bucketName;
+        }
+        else if (dependencies.bucket) {
+            var bucketName = dependencies.bucket.name;
+            if (options.bucketName && options.bucketName !== bucketName) {
+                throw new Error("Injected Couchbase bucket targets ".concat(bucketName, ", not requested bucket ").concat(options.bucketName));
+            }
+            this.settings.bucketName = bucketName;
+        }
+        else if (dependencies.cluster && !options.bucketName) {
+            throw new Error('bucketName is required when injecting a Couchbase cluster');
+        }
+        this.connection =
+            dependencies.connection || new DirectConnection(this.settings, dependencies);
+        (options.models || []).forEach(function (definition) { return _this.model(definition); });
+    }
+    CouchsetClient.prototype.ready = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.connection.ready()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, this];
+                }
+            });
+        });
+    };
+    CouchsetClient.prototype.shutdown = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var shutdown;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        shutdown = this.connection.shutdown;
+                        if (!(typeof shutdown === 'function')) return [3 /*break*/, 2];
+                        return [4 /*yield*/, shutdown.call(this.connection)];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    CouchsetClient.prototype.definitions = function () {
+        return Array.from(this.registered.values()).map(function (_a) {
+            var definition = _a.definition;
+            return definition;
+        });
+    };
+    /** Bind and register a definition without provisioning or index DDL. */
+    CouchsetClient.prototype.model = function (definition) {
+        var identity = modelIdentity(definition);
+        var existing = this.registered.get(identity);
+        if (existing) {
+            assertSameDefinition(existing.definition, definition);
+            return existing.model;
+        }
+        var model = new model_1.Model(definition.name, definition, this.connection);
+        this.registered.set(identity, { definition: definition, model: model });
+        return model;
+    };
+    /**
+     * Async registration for dynamic models. DDL is performed only when the
+     * caller explicitly opts into provision; ordinary model() is side-effect-free.
+     */
+    CouchsetClient.prototype.registerModel = function (definition_1) {
+        return __awaiter(this, arguments, void 0, function (definition, options) {
+            var model, requested, config;
+            if (options === void 0) { options = {}; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        model = this.model(definition);
+                        requested = options.provision;
+                        if (!requested) return [3 /*break*/, 2];
+                        config = typeof requested === 'boolean' ? { collections: true, indexes: true } : requested;
+                        return [4 /*yield*/, this.provision({
+                                collections: config.collections !== false,
+                                indexes: config.indexes !== false,
+                                models: [definition],
+                                timeoutMs: options.timeoutMs,
+                                waitForIndexes: config.waitForIndexes,
+                            })];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2: return [2 /*return*/, model];
+                }
+            });
+        });
+    };
+    /** Create only missing scopes/collections. Existing resources are never altered. */
+    CouchsetClient.prototype.ensureCollections = function () {
+        return __awaiter(this, arguments, void 0, function (options) {
+            var targets, manager, manifest, error_1, result, _loop_1, this_1, targets_1, targets_1_1, target, e_1_1;
+            var e_1, _a;
+            if (options === void 0) { options = {}; }
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.ready()];
+                    case 1:
+                        _b.sent();
+                        targets = this.targets(options.models);
+                        manager = this.connection.bucket.collections();
+                        _b.label = 2;
+                    case 2:
+                        _b.trys.push([2, 4, , 5]);
+                        return [4 /*yield*/, manager.getAllScopes()];
+                    case 3:
+                        manifest = _b.sent();
+                        return [3 /*break*/, 5];
+                    case 4:
+                        error_1 = _b.sent();
+                        throw provisionError('read the scope manifest for', this.settings.bucketName, error_1);
+                    case 5:
+                        result = [];
+                        _loop_1 = function (target) {
+                            var defaultTarget, scope, createdScope, error_2, exists, createdCollection, error_3;
+                            return __generator(this, function (_c) {
+                                switch (_c.label) {
+                                    case 0:
+                                        defaultTarget = target.scope === '_default' && target.collection === '_default';
+                                        if (defaultTarget) {
+                                            result.push(__assign(__assign({}, target), { createdScope: false, createdCollection: false }));
+                                            return [2 /*return*/, "continue"];
+                                        }
+                                        scope = findScope(manifest, target.scope);
+                                        createdScope = false;
+                                        if (!(!scope && target.scope !== '_default')) return [3 /*break*/, 6];
+                                        _c.label = 1;
+                                    case 1:
+                                        _c.trys.push([1, 3, , 4]);
+                                        return [4 /*yield*/, manager.createScope(target.scope)];
+                                    case 2:
+                                        _c.sent();
+                                        createdScope = true;
+                                        return [3 /*break*/, 4];
+                                    case 3:
+                                        error_2 = _c.sent();
+                                        if (!isAlreadyExists(error_2)) {
+                                            throw provisionError('create scope', target.scope, error_2);
+                                        }
+                                        return [3 /*break*/, 4];
+                                    case 4: return [4 /*yield*/, this_1.waitForCollectionManifest(target.scope, undefined, options)];
+                                    case 5:
+                                        manifest = _c.sent();
+                                        scope = findScope(manifest, target.scope);
+                                        _c.label = 6;
+                                    case 6:
+                                        if (!scope) {
+                                            throw new Error("CouchSet could not find scope ".concat(target.scope, " after provisioning"));
+                                        }
+                                        exists = (scope.collections || []).some(function (item) { return item.name === target.collection; });
+                                        createdCollection = false;
+                                        if (!!exists) return [3 /*break*/, 10];
+                                        _c.label = 7;
+                                    case 7:
+                                        _c.trys.push([7, 9, , 10]);
+                                        return [4 /*yield*/, manager.createCollection(target.collection, target.scope, target.settings || {})];
+                                    case 8:
+                                        _c.sent();
+                                        createdCollection = true;
+                                        return [3 /*break*/, 10];
+                                    case 9:
+                                        error_3 = _c.sent();
+                                        if (!isAlreadyExists(error_3)) {
+                                            throw provisionError('create collection', "".concat(target.scope, ".").concat(target.collection), error_3);
+                                        }
+                                        return [3 /*break*/, 10];
+                                    case 10: return [4 /*yield*/, this_1.waitForCollectionManifest(target.scope, target.collection, options)];
+                                    case 11:
+                                        _c.sent();
+                                        result.push(__assign(__assign({}, target), { createdScope: createdScope, createdCollection: createdCollection }));
+                                        return [2 /*return*/];
+                                }
+                            });
+                        };
+                        this_1 = this;
+                        _b.label = 6;
+                    case 6:
+                        _b.trys.push([6, 11, 12, 13]);
+                        targets_1 = __values(targets), targets_1_1 = targets_1.next();
+                        _b.label = 7;
+                    case 7:
+                        if (!!targets_1_1.done) return [3 /*break*/, 10];
+                        target = targets_1_1.value;
+                        return [5 /*yield**/, _loop_1(target)];
+                    case 8:
+                        _b.sent();
+                        _b.label = 9;
+                    case 9:
+                        targets_1_1 = targets_1.next();
+                        return [3 /*break*/, 7];
+                    case 10: return [3 /*break*/, 13];
+                    case 11:
+                        e_1_1 = _b.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 13];
+                    case 12:
+                        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 13: return [2 /*return*/, result];
+                }
+            });
+        });
+    };
+    /** Explicit bootstrap: provisioning occurs before index creation. */
+    CouchsetClient.prototype.provision = function () {
+        return __awaiter(this, arguments, void 0, function (options) {
+            var definitions, collections, _a, indexes, _b;
+            if (options === void 0) { options = {}; }
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        definitions = options.models || this.definitions();
+                        if (!(options.collections === false)) return [3 /*break*/, 1];
+                        _a = [];
+                        return [3 /*break*/, 3];
+                    case 1: return [4 /*yield*/, this.ensureCollections(__assign(__assign({}, options), { models: definitions }))];
+                    case 2:
+                        _a = _c.sent();
+                        _c.label = 3;
+                    case 3:
+                        collections = _a;
+                        if (!options.indexes) return [3 /*break*/, 5];
+                        return [4 /*yield*/, this.ensureIndexes({
+                                models: definitions,
+                                waitForIndexes: options.waitForIndexes,
+                                timeoutMs: options.timeoutMs,
+                            })];
+                    case 4:
+                        _b = _c.sent();
+                        return [3 /*break*/, 6];
+                    case 5:
+                        _b = [];
+                        _c.label = 6;
+                    case 6:
+                        indexes = _b;
+                        return [2 /*return*/, { collections: collections, indexes: indexes }];
+                }
+            });
+        });
+    };
+    /** Normal ensureIndexes stays create-only. It never checks, drops, or changes an existing index. */
+    CouchsetClient.prototype.ensureIndexes = function () {
+        return __awaiter(this, arguments, void 0, function (options) {
+            var definitions, queries, indexes, _loop_2, this_2, definitions_1, definitions_1_1, definition, e_2_1;
+            var e_2, _a;
+            if (options === void 0) { options = {}; }
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.ready()];
+                    case 1:
+                        _b.sent();
+                        definitions = options.models || this.definitions();
+                        queries = [];
+                        indexes = [];
+                        _loop_2 = function (definition) {
+                            var model, statements;
+                            return __generator(this, function (_c) {
+                                switch (_c.label) {
+                                    case 0:
+                                        model = this_2.model(definition);
+                                        return [4 /*yield*/, model.ensureIndexes({ deferred: options.deferred })];
+                                    case 1:
+                                        statements = _c.sent();
+                                        queries.push.apply(queries, __spreadArray([], __read(statements), false));
+                                        indexes.push.apply(indexes, __spreadArray([], __read((definition.indexes || []).map(function (index) { return ({
+                                            name: index.name,
+                                            target: definitionTarget(definition),
+                                        }); })), false));
+                                        return [2 /*return*/];
+                                }
+                            });
+                        };
+                        this_2 = this;
+                        _b.label = 2;
+                    case 2:
+                        _b.trys.push([2, 7, 8, 9]);
+                        definitions_1 = __values(definitions), definitions_1_1 = definitions_1.next();
+                        _b.label = 3;
+                    case 3:
+                        if (!!definitions_1_1.done) return [3 /*break*/, 6];
+                        definition = definitions_1_1.value;
+                        return [5 /*yield**/, _loop_2(definition)];
+                    case 4:
+                        _b.sent();
+                        _b.label = 5;
+                    case 5:
+                        definitions_1_1 = definitions_1.next();
+                        return [3 /*break*/, 3];
+                    case 6: return [3 /*break*/, 9];
+                    case 7:
+                        e_2_1 = _b.sent();
+                        e_2 = { error: e_2_1 };
+                        return [3 /*break*/, 9];
+                    case 8:
+                        try {
+                            if (definitions_1_1 && !definitions_1_1.done && (_a = definitions_1.return)) _a.call(definitions_1);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                        return [7 /*endfinally*/];
+                    case 9:
+                        if (!(options.waitForIndexes && indexes.length)) return [3 /*break*/, 11];
+                        return [4 /*yield*/, this.waitForIndexes(indexes, options.timeoutMs)];
+                    case 10:
+                        _b.sent();
+                        _b.label = 11;
+                    case 11: return [2 /*return*/, queries];
+                }
+            });
+        });
+    };
+    /** Report missing, matching, and drifted indexes; this method has no DDL side effects. */
+    CouchsetClient.prototype.planIndexes = function () {
+        return __awaiter(this, arguments, void 0, function (options) {
+            var rows, items, _loop_3, this_3, _a, _b, definition;
+            var e_3, _c;
+            if (options === void 0) { options = {}; }
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0: return [4 /*yield*/, this.ready()];
+                    case 1:
+                        _d.sent();
+                        return [4 /*yield*/, this.indexCatalog()];
+                    case 2:
+                        rows = _d.sent();
+                        items = [];
+                        _loop_3 = function (definition) {
+                            var e_4, _e;
+                            var keyspace = this_3.keyspace(definition);
+                            var target = definitionTarget(definition);
+                            var _loop_4 = function (index) {
+                                var matchingRows = rows.filter(function (row) { return indexRowMatchesTarget(row, definition); });
+                                var desired = matchingRows.find(function (row) { return row.name === index.name; });
+                                var replacementName = versionedIndexName(index.name, index);
+                                var replacement = matchingRows.find(function (row) { return row.name === replacementName; });
+                                // A previous safe rollout may have dropped the old logical name
+                                // while retaining this deterministic replacement physical name.
+                                if (replacement && indexMatches(replacement, index)) {
+                                    items.push({
+                                        createAs: replacementName,
+                                        definition: index,
+                                        keyspace: keyspace,
+                                        status: 'matching',
+                                        target: target,
+                                    });
+                                    return "continue";
+                                }
+                                if (desired && indexMatches(desired, index)) {
+                                    items.push({
+                                        createAs: index.name,
+                                        definition: index,
+                                        keyspace: keyspace,
+                                        status: 'matching',
+                                        target: target,
+                                    });
+                                    return "continue";
+                                }
+                                // `replaces` explicitly asks for a new physical index, even if
+                                // the predecessor happens to have equivalent keys.
+                                var predecessorName = index.replaces || index.name;
+                                var predecessor = matchingRows.find(function (row) { return row.name === predecessorName; });
+                                if (!predecessor) {
+                                    items.push({
+                                        createAs: index.name,
+                                        definition: index,
+                                        keyspace: keyspace,
+                                        status: 'create',
+                                        target: target,
+                                    });
+                                    return "continue";
+                                }
+                                var createAs = index.replaces ? index.name : replacementName;
+                                items.push({
+                                    createAs: createAs,
+                                    definition: index,
+                                    keyspace: keyspace,
+                                    reason: 'Declared keys, predicate, or primary mode differs from the live index.',
+                                    replaces: predecessor.name,
+                                    status: 'replace',
+                                    target: target,
+                                });
+                            };
+                            try {
+                                for (var _f = (e_4 = void 0, __values(definition.indexes || [])), _g = _f.next(); !_g.done; _g = _f.next()) {
+                                    var index = _g.value;
+                                    _loop_4(index);
+                                }
+                            }
+                            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                            finally {
+                                try {
+                                    if (_g && !_g.done && (_e = _f.return)) _e.call(_f);
+                                }
+                                finally { if (e_4) throw e_4.error; }
+                            }
+                        };
+                        this_3 = this;
+                        try {
+                            for (_a = __values(options.models || this.definitions()), _b = _a.next(); !_b.done; _b = _a.next()) {
+                                definition = _b.value;
+                                _loop_3(definition);
+                            }
+                        }
+                        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                        finally {
+                            try {
+                                if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                            }
+                            finally { if (e_3) throw e_3.error; }
+                        }
+                        return [2 /*return*/, { items: items }];
+                }
+            });
+        });
+    };
+    /**
+     * Apply a reviewed plan by creating versioned replacements and waiting for
+     * them. Dropping old indexes is deliberately an explicit second opt-in.
+     */
+    CouchsetClient.prototype.applyIndexPlan = function (plan_1) {
+        return __awaiter(this, arguments, void 0, function (plan, options) {
+            var applied, replacements, _a, _b, item, definition, query, e_5_1, _c, _d, item, e_6_1;
+            var e_5, _e, e_6, _f;
+            if (options === void 0) { options = {}; }
+            return __generator(this, function (_g) {
+                switch (_g.label) {
+                    case 0: return [4 /*yield*/, this.ready()];
+                    case 1:
+                        _g.sent();
+                        applied = [];
+                        replacements = [];
+                        _g.label = 2;
+                    case 2:
+                        _g.trys.push([2, 7, 8, 9]);
+                        _a = __values(plan.items), _b = _a.next();
+                        _g.label = 3;
+                    case 3:
+                        if (!!_b.done) return [3 /*break*/, 6];
+                        item = _b.value;
+                        if (item.status === 'matching') {
+                            return [3 /*break*/, 5];
+                        }
+                        definition = __assign(__assign({}, item.definition), { name: item.createAs });
+                        query = (0, indexes_1.buildIndexQuery)(item.keyspace, definition);
+                        return [4 /*yield*/, this.connection.cluster.query(query)];
+                    case 4:
+                        _g.sent();
+                        applied.push(query);
+                        replacements.push({ name: item.createAs, target: item.target });
+                        _g.label = 5;
+                    case 5:
+                        _b = _a.next();
+                        return [3 /*break*/, 3];
+                    case 6: return [3 /*break*/, 9];
+                    case 7:
+                        e_5_1 = _g.sent();
+                        e_5 = { error: e_5_1 };
+                        return [3 /*break*/, 9];
+                    case 8:
+                        try {
+                            if (_b && !_b.done && (_e = _a.return)) _e.call(_a);
+                        }
+                        finally { if (e_5) throw e_5.error; }
+                        return [7 /*endfinally*/];
+                    case 9:
+                        if (!replacements.length) return [3 /*break*/, 11];
+                        return [4 /*yield*/, this.waitForIndexes(replacements, options.timeoutMs)];
+                    case 10:
+                        _g.sent();
+                        _g.label = 11;
+                    case 11:
+                        if (!options.dropReplaced) return [3 /*break*/, 19];
+                        _g.label = 12;
+                    case 12:
+                        _g.trys.push([12, 17, 18, 19]);
+                        _c = __values(plan.items), _d = _c.next();
+                        _g.label = 13;
+                    case 13:
+                        if (!!_d.done) return [3 /*break*/, 16];
+                        item = _d.value;
+                        if (!(item.status === 'replace' && item.replaces)) return [3 /*break*/, 15];
+                        return [4 /*yield*/, this.connection.cluster.query("DROP INDEX ".concat(item.keyspace, ".").concat((0, keyspace_1.escapeIdentifier)(item.replaces)))];
+                    case 14:
+                        _g.sent();
+                        _g.label = 15;
+                    case 15:
+                        _d = _c.next();
+                        return [3 /*break*/, 13];
+                    case 16: return [3 /*break*/, 19];
+                    case 17:
+                        e_6_1 = _g.sent();
+                        e_6 = { error: e_6_1 };
+                        return [3 /*break*/, 19];
+                    case 18:
+                        try {
+                            if (_d && !_d.done && (_f = _c.return)) _f.call(_c);
+                        }
+                        finally { if (e_6) throw e_6.error; }
+                        return [7 /*endfinally*/];
+                    case 19: return [2 /*return*/, applied];
+                }
+            });
+        });
+    };
+    /**
+     * Run the callback through Couchbase's transaction retry loop. The callback
+     * may execute more than once; do not perform external side effects inside it.
+     * A commit-ambiguous error is rethrown and must be resolved by the caller via
+     * an idempotency key/outbox, never by blindly retrying a side effect.
+     */
+    CouchsetClient.prototype.transaction = function (callback) {
+        return __awaiter(this, void 0, void 0, function () {
+            var result;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.ready()];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.connection.cluster.transactions().run(function (attempt) { return __awaiter(_this, void 0, void 0, function () {
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0: return [4 /*yield*/, callback(new CouchsetTransaction(this, attempt))];
+                                        case 1:
+                                            result = _a.sent();
+                                            return [2 /*return*/];
+                                    }
+                                });
+                            }); })];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/, result];
+                }
+            });
+        });
+    };
+    CouchsetClient.prototype.keyspace = function (definition) {
+        var target = definitionTarget(definition);
+        return (0, keyspace_1.keyspaceIdentifier)({
+            bucketName: this.settings.bucketName,
+            collectionName: target.collection,
+            scopeName: target.scope,
+        });
+    };
+    CouchsetClient.prototype.getConnection = function () {
+        return this.connection;
+    };
+    CouchsetClient.prototype.targets = function (definitions) {
+        var e_7, _a;
+        var targets = new Map();
+        try {
+            for (var _b = __values(definitions || this.definitions()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var definition = _c.value;
+                var target = definitionTarget(definition);
+                var identity = "".concat(target.scope, ".").concat(target.collection);
+                var existing = targets.get(identity);
+                var settings = definition.collectionSettings;
+                if (existing &&
+                    JSON.stringify(existing.settings || {}) !== JSON.stringify(settings || {})) {
+                    throw new Error("Conflicting collection settings declared for ".concat(identity, "; CouchSet will not alter an existing collection"));
+                }
+                targets.set(identity, __assign(__assign({}, target), { settings: settings }));
+            }
+        }
+        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_7) throw e_7.error; }
+        }
+        return Array.from(targets.values());
+    };
+    CouchsetClient.prototype.waitForCollectionManifest = function (scopeName, collectionName, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var manager, timeout, poll, deadline, manifest, scope, error_4;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        manager = this.connection.bucket.collections();
+                        timeout = options.timeoutMs || 30000;
+                        poll = options.pollIntervalMs || 100;
+                        deadline = Date.now() + timeout;
+                        _a.label = 1;
+                    case 1:
+                        if (!(Date.now() <= deadline)) return [3 /*break*/, 7];
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, 4, , 5]);
+                        return [4 /*yield*/, manager.getAllScopes()];
+                    case 3:
+                        manifest = _a.sent();
+                        scope = findScope(manifest, scopeName);
+                        if (scope &&
+                            (!collectionName ||
+                                (scope.collections || []).some(function (item) { return item.name === collectionName; }))) {
+                            return [2 /*return*/, manifest];
+                        }
+                        return [3 /*break*/, 5];
+                    case 4:
+                        error_4 = _a.sent();
+                        if (!isNotFound(error_4)) {
+                            throw provisionError('wait for collection metadata', "".concat(scopeName, ".").concat(collectionName || ''), error_4);
+                        }
+                        return [3 /*break*/, 5];
+                    case 5: return [4 /*yield*/, delay(poll)];
+                    case 6:
+                        _a.sent();
+                        return [3 /*break*/, 1];
+                    case 7: throw new Error("Timed out waiting for Couchbase collection ".concat(scopeName, ".").concat(collectionName || '', " to appear in the manifest"));
+                }
+            });
+        });
+    };
+    CouchsetClient.prototype.waitForIndexes = function (indexes_2) {
+        return __awaiter(this, arguments, void 0, function (indexes, timeoutMs) {
+            var deadline, _loop_5, this_4, state_1;
+            if (timeoutMs === void 0) { timeoutMs = 30000; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        deadline = Date.now() + timeoutMs;
+                        _loop_5 = function () {
+                            var rows;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0: return [4 /*yield*/, this_4.indexCatalog()];
+                                    case 1:
+                                        rows = _b.sent();
+                                        if (indexes.every(function (index) {
+                                            return rows.some(function (row) {
+                                                return row.name === index.name &&
+                                                    String(row.state).toLowerCase() === 'online' &&
+                                                    indexRowMatchesCollection(row, index.target);
+                                            });
+                                        })) {
+                                            return [2 /*return*/, { value: void 0 }];
+                                        }
+                                        return [4 /*yield*/, delay(100)];
+                                    case 2:
+                                        _b.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        };
+                        this_4 = this;
+                        _a.label = 1;
+                    case 1:
+                        if (!(Date.now() <= deadline)) return [3 /*break*/, 3];
+                        return [5 /*yield**/, _loop_5()];
+                    case 2:
+                        state_1 = _a.sent();
+                        if (typeof state_1 === "object")
+                            return [2 /*return*/, state_1.value];
+                        return [3 /*break*/, 1];
+                    case 3: throw new Error("Timed out waiting for Couchbase indexes to become online: ".concat(indexes
+                        .map(function (index) { return index.name; })
+                        .join(', ')));
+                }
+            });
+        });
+    };
+    CouchsetClient.prototype.indexCatalog = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.connection.cluster.query('SELECT name, bucket_id, keyspace_id, scope_id, collection_id, index_key, condition, is_primary, state FROM system:indexes WHERE bucket_id = $bucket OR keyspace_id = $bucket', { parameters: { bucket: this.settings.bucketName } })];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, result.rows || []];
+                }
+            });
+        });
+    };
+    return CouchsetClient;
+}());
+exports.CouchsetClient = CouchsetClient;
+/** A model bound strictly to a Couchbase transaction attempt. */
+var TransactionModel = /** @class */ (function () {
+    function TransactionModel(model, attempt) {
+        this.model = model;
+        this.attempt = attempt;
+    }
+    TransactionModel.prototype.get = function (id) {
+        return __awaiter(this, void 0, void 0, function () {
+            var document_1, error_5;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.attempt.get(this.model.getCollection(), id)];
+                    case 1:
+                        document_1 = _a.sent();
+                        return [2 /*return*/, { content: this.model.parse(document_1.content), document: document_1 }];
+                    case 2:
+                        error_5 = _a.sent();
+                        if (isNotFound(error_5)) {
+                            return [2 /*return*/, null];
+                        }
+                        throw error_5;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    TransactionModel.prototype.getById = function (id) {
+        return this.get(id);
+    };
+    TransactionModel.prototype.insert = function (id, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var stored, document;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.model.prepareInsert(__assign(__assign({}, data), { id: id }))];
+                    case 1:
+                        stored = _a.sent();
+                        return [4 /*yield*/, this.attempt.insert(this.model.getCollection(), id, stored)];
+                    case 2:
+                        document = _a.sent();
+                        return [2 /*return*/, {
+                                content: this.model.parse(document.content || stored),
+                                document: document,
+                            }];
+                }
+            });
+        });
+    };
+    /** Replace requires the prior transactional read, as required by the SDK. */
+    TransactionModel.prototype.replace = function (document, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var stored, replacement;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.model.prepareReplace(document.content.id, data)];
+                    case 1:
+                        stored = _a.sent();
+                        return [4 /*yield*/, this.attempt.replace(document.document, stored)];
+                    case 2:
+                        replacement = _a.sent();
+                        return [2 /*return*/, {
+                                content: this.model.parse(replacement.content || stored),
+                                document: replacement,
+                            }];
+                }
+            });
+        });
+    };
+    TransactionModel.prototype.replaceById = function (id, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var current;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.get(id)];
+                    case 1:
+                        current = _a.sent();
+                        if (!current) {
+                            throw new Error("Cannot replace missing transaction document ".concat(id));
+                        }
+                        return [2 /*return*/, this.replace(current, data)];
+                }
+            });
+        });
+    };
+    TransactionModel.prototype.remove = function (document) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.attempt.remove(document.document)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    TransactionModel.prototype.query = function (statement, options) {
+        return this.attempt.query(statement, options);
+    };
+    return TransactionModel;
+}());
+exports.TransactionModel = TransactionModel;
+var CouchsetTransaction = /** @class */ (function () {
+    function CouchsetTransaction(client, attempt) {
+        this.client = client;
+        this.attempt = attempt;
+    }
+    CouchsetTransaction.prototype.model = function (definition) {
+        return new TransactionModel(this.client.model(definition), this.attempt);
+    };
+    CouchsetTransaction.prototype.query = function (statement, options) {
+        return this.attempt.query(statement, options);
+    };
+    return CouchsetTransaction;
+}());
+exports.CouchsetTransaction = CouchsetTransaction;
+/**
+ * Creates a short-lived scoped fixture and a cleanup function. The caller must
+ * invoke cleanup in after/afterEach; no normal client operation ever drops data.
+ */
+var createCouchsetTestFixture = function (client, definition) { return __awaiter(void 0, void 0, void 0, function () {
+    var suffix, fixtureScope, generatedScope, scoped, model;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                suffix = (0, uuid_1.generateUUID)().replace(/-/g, '').slice(0, 12);
+                fixtureScope = definition.scope || "couchset_test_".concat(suffix);
+                generatedScope = fixtureScope !== definition.scope;
+                scoped = (0, exports.defineModel)(__assign(__assign({}, definition), { collection: definition.collection || "fixture_".concat(suffix), scope: fixtureScope }));
+                return [4 /*yield*/, client.registerModel(scoped, { provision: { collections: true } })];
+            case 1:
+                model = _a.sent();
+                return [2 /*return*/, {
+                        definition: scoped,
+                        model: model,
+                        cleanup: function () { return __awaiter(void 0, void 0, void 0, function () {
+                            var target, manager, error_6, error_7;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        target = definitionTarget(scoped);
+                                        manager = client.getConnection().bucket.collections();
+                                        _a.label = 1;
+                                    case 1:
+                                        _a.trys.push([1, 3, , 4]);
+                                        return [4 /*yield*/, manager.dropCollection(target.collection, target.scope)];
+                                    case 2:
+                                        _a.sent();
+                                        return [3 /*break*/, 4];
+                                    case 3:
+                                        error_6 = _a.sent();
+                                        if (!isNotFound(error_6)) {
+                                            throw provisionError('drop fixture collection', "".concat(target.scope, ".").concat(target.collection), error_6);
+                                        }
+                                        return [3 /*break*/, 4];
+                                    case 4:
+                                        if (!generatedScope) return [3 /*break*/, 8];
+                                        _a.label = 5;
+                                    case 5:
+                                        _a.trys.push([5, 7, , 8]);
+                                        return [4 /*yield*/, manager.dropScope(target.scope)];
+                                    case 6:
+                                        _a.sent();
+                                        return [3 /*break*/, 8];
+                                    case 7:
+                                        error_7 = _a.sent();
+                                        if (!isNotFound(error_7)) {
+                                            throw provisionError('drop fixture scope', target.scope, error_7);
+                                        }
+                                        return [3 /*break*/, 8];
+                                    case 8: return [2 /*return*/];
+                                }
+                            });
+                        }); },
+                    }];
+        }
+    });
+}); };
+exports.createCouchsetTestFixture = createCouchsetTestFixture;
+var createCouchsetClient = function (options) {
+    if (options === void 0) { options = {}; }
+    return new CouchsetClient(options);
+};
+exports.createCouchsetClient = createCouchsetClient;
+var definitionTarget = function (definition) { return ({
+    collection: Object.prototype.hasOwnProperty.call(definition, 'collection')
+        ? definition.collection || '_default'
+        : '_default',
+    scope: Object.prototype.hasOwnProperty.call(definition, 'scope')
+        ? definition.scope || '_default'
+        : '_default',
+}); };
+var modelIdentity = function (definition) {
+    var target = definitionTarget(definition);
+    return "".concat(target.scope, ".").concat(target.collection, ".").concat(definition.name);
+};
+var assertSameDefinition = function (left, right) {
+    if (!sameValue(left, right)) {
+        throw new Error("Model ".concat(modelIdentity(left), " is already registered with a different definition; create a separate client or use a new model name"));
+    }
+};
+var sameValue = function (left, right) {
+    if (left === right) {
+        return true;
+    }
+    if (!left || !right || typeof left !== 'object' || typeof right !== 'object') {
+        return false;
+    }
+    if (left instanceof Date || right instanceof Date) {
+        return left instanceof Date && right instanceof Date && left.getTime() === right.getTime();
+    }
+    if (Array.isArray(left) || Array.isArray(right)) {
+        return (Array.isArray(left) &&
+            Array.isArray(right) &&
+            left.length === right.length &&
+            left.every(function (item, index) { return sameValue(item, right[index]); }));
+    }
+    var leftKeys = Object.keys(left).sort();
+    var rightKeys = Object.keys(right).sort();
+    return (leftKeys.length === rightKeys.length &&
+        leftKeys.every(function (key, index) { return key === rightKeys[index] && sameValue(left[key], right[key]); }));
+};
+var findScope = function (scopes, name) { return scopes.find(function (scope) { return scope.name === name; }); };
+var normalize = function (value) {
+    return JSON.stringify(value || '')
+        .replace(/[\s`()"']/g, '')
+        .toLowerCase();
+};
+var indexMatches = function (row, definition) {
+    if (!!row.is_primary !== !!definition.primary) {
+        return false;
+    }
+    if (definition.primary) {
+        return true;
+    }
+    var expectedKeys = (definition.fields || []).map(function (field) {
+        if (typeof field === 'string') {
+            return field;
+        }
+        var key = Object.keys(field)[0];
+        return "".concat(key, " ").concat(field[key]);
+    });
+    return (normalize(row.index_key) === normalize(expectedKeys) &&
+        normalize(row.condition) === normalize(indexCondition(definition)));
+};
+/** Match Couchbase's catalogued SQL++ condition against the same SQL++ we declare. */
+var indexCondition = function (definition) {
+    return (0, builders_1.buildWhereExpr)(definition.where).replace(/^\s*WHERE\s+/i, '');
+};
+var indexRowMatchesTarget = function (row, definition) {
+    return indexRowMatchesCollection(row, definitionTarget(definition));
+};
+var indexRowMatchesCollection = function (row, target) {
+    // On current Couchbase Server, scoped collection indexes expose the
+    // collection in keyspace_id and omit collection_id. Older/default targets
+    // may use keyspace_id for the bucket, so prefer collection_id when present.
+    var collection = row.collection_id || (row.scope_id ? row.keyspace_id : undefined);
+    return ((!row.scope_id || row.scope_id === target.scope) &&
+        (!collection || collection === target.collection));
+};
+var versionedIndexName = function (name, definition) {
+    var fingerprint = JSON.stringify({
+        fields: definition.fields,
+        primary: definition.primary,
+        where: definition.where,
+    })
+        .split('')
+        .reduce(function (hash, character) { return (hash * 31 + character.charCodeAt(0)) >>> 0; }, 7)
+        .toString(36);
+    return "".concat(name, "_v").concat(fingerprint);
+};
+//# sourceMappingURL=next.js.map