couchset 0.2.7 → 0.4.0

package/dist/model/index.js

@@ -57,40 +57,164 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
+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 __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 __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Model = void 0;
-// import {AutomaticMethodOptions, AutomaticOutput, automateImplementation} from '../automate';
-var search_1 = require("../search");
 var utils_1 = require("../utils");
 var connection_1 = __importDefault(require("../connection"));
-var pagination_1 = require("../pagination");
-var uuid_1 = require("../uuid");
+var default_scope_1 = require("./default-scope");
+var read_helpers_1 = require("./read-helpers");
+var keyspace_1 = require("./keyspace");
+var safe_query_1 = require("./safe-query");
+var write_helpers_1 = require("./write-helpers");
+var hydrated_document_1 = require("./hydrated-document");
+var indexes_1 = require("./indexes");
+var validation_1 = require("./validation");
 var Model = /** @class */ (function () {
-    function Model(name, options) {
+    function Model(name, options, connection) {
         this.scope = '_default';
+        this.defaultWhereMode = 'default';
+        this.softDelete = false;
+        this.codecs = {};
+        this.indexes = [];
         this.schema = {
             createdAt: 'date',
             updatedAt: 'date',
         };
-        this.graphqlType = null;
         // this.collection = CouchbaseConnection.Instance.getCollection();
         this.collectionName = name;
+        this.connection = connection;
         if (options) {
-            this.graphqlType = (options && options.graphqlType) || null;
+            var hasScope = Object.prototype.hasOwnProperty.call(options, 'scope');
+            var hasCollection = Object.prototype.hasOwnProperty.call(options, 'collection');
             this.scope = (options && options.scope) || '_default';
-            this.schema = __assign(__assign({}, ((options && options.schema) || {})), { createdAt: 'date', updatedAt: 'date' });
+            this.scopeName = hasScope ? this.scope : undefined;
+            this.collectionTargetName = hasCollection
+                ? options.collection || '_default'
+                : undefined;
+            this.softDelete = !!options.softDelete;
+            this.defaultWhere = options.defaultWhere;
+            this.validateCreateHook = options.validateCreate;
+            this.validateReplaceHook = options.validateReplace;
+            this.parseHook = options.parse;
+            this.dateFields = options.dateFields;
+            this.codecs = options.codecs || {};
+            var dateFields_1 = new Set(options.dateFields || []);
+            Object.keys(this.codecs).forEach(function (field) {
+                var _a;
+                if (dateFields_1.has(field) || ((_a = options.schema) === null || _a === void 0 ? void 0 : _a[field]) === 'date') {
+                    throw new Error("codec for ".concat(field, " conflicts with dateFields or schema date; use one transform"));
+                }
+            });
+            this.indexes = options.indexes || [];
+            this.schema = __assign(__assign(__assign({}, ((options && options.schema) || {})), (0, validation_1.schemaFromDateFields)(options.dateFields)), { createdAt: 'date', updatedAt: 'date' });
+        }
+        // Legacy models participate in the singleton registry. Client-bound
+        // models are registered only by their owning CouchsetClient.
+        if (this.indexes.length && !this.connection) {
+            Model.registeredModels.push(this);
         }
     }
     /**
-     * Set setGraphqlType
-     * setGraphqlType
+     * Ensure indexes for every constructed model with index declarations.
      */
-    Model.prototype.setGraphqlType = function (gqlType) {
-        this.graphqlType = gqlType;
-        return this;
+    Model.ensureIndexes = function (options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queries, seenQueries, _loop_1, _a, _b, model, e_1_1;
+            var e_1, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        queries = [];
+                        seenQueries = new Set();
+                        _loop_1 = function (model) {
+                            var statements, pending;
+                            return __generator(this, function (_e) {
+                                switch (_e.label) {
+                                    case 0: return [4 /*yield*/, model.prepare()];
+                                    case 1:
+                                        _e.sent();
+                                        statements = model.indexStatements(options);
+                                        pending = statements.filter(function (query) { return !seenQueries.has(query); });
+                                        pending.forEach(function (query) { return seenQueries.add(query); });
+                                        return [4 /*yield*/, (0, indexes_1.ensureModelIndexes)(model.couchbaseConnection().cluster, model.keyspace(), model.indexes.filter(function (index, indexPosition) {
+                                                return pending.includes(statements[indexPosition]);
+                                            }), options)];
+                                    case 2:
+                                        _e.sent();
+                                        queries.push.apply(queries, __spreadArray([], __read(pending), false));
+                                        return [2 /*return*/];
+                                }
+                            });
+                        };
+                        _d.label = 1;
+                    case 1:
+                        _d.trys.push([1, 6, 7, 8]);
+                        _a = __values(Model.registeredModels), _b = _a.next();
+                        _d.label = 2;
+                    case 2:
+                        if (!!_b.done) return [3 /*break*/, 5];
+                        model = _b.value;
+                        return [5 /*yield**/, _loop_1(model)];
+                    case 3:
+                        _d.sent();
+                        _d.label = 4;
+                    case 4:
+                        _b = _a.next();
+                        return [3 /*break*/, 2];
+                    case 5: return [3 /*break*/, 8];
+                    case 6:
+                        e_1_1 = _d.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 8];
+                    case 7:
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                        return [7 /*endfinally*/];
+                    case 8: return [2 /*return*/, queries];
+                }
+            });
+        });
     };
     /**
      * Refresh and get default collection from CouchbaseConnection
@@ -100,22 +224,75 @@ var Model = /** @class */ (function () {
      */
     Model.prototype.fresh = function () {
         // if couchbase connection has been init
-        if (connection_1.default.Instance.bucketName) {
-            this.collection = connection_1.default.Instance.getCollection();
+        if (this.couchbaseConnection().isConnected()) {
+            var target = this.collectionTarget();
+            this.collection = this.couchbaseConnection().getCollection(target.scopeName, target.collectionName);
         }
     };
+    Model.prototype.prepare = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var connection, target;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        connection = this.couchbaseConnection();
+                        if (!!connection.bucket) return [3 /*break*/, 2];
+                        return [4 /*yield*/, connection.ready()];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        target = this.collectionTarget();
+                        this.collection = connection.getCollection(target.scopeName, target.collectionName);
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Model.prototype.withConnection = function (operation) {
+        return __awaiter(this, void 0, void 0, function () {
+            var error_1, connection;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.prepare()];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, 4, , 6]);
+                        return [4 /*yield*/, operation()];
+                    case 3: return [2 /*return*/, _a.sent()];
+                    case 4:
+                        error_1 = _a.sent();
+                        connection = this.couchbaseConnection();
+                        if (!connection.shouldReconnect(error_1)) {
+                            throw error_1;
+                        }
+                        connection.markDisconnected(error_1);
+                        return [4 /*yield*/, this.prepare()];
+                    case 5:
+                        _a.sent();
+                        return [2 /*return*/, operation()];
+                    case 6: return [2 /*return*/];
+                }
+            });
+        });
+    };
     /** Get this collection
      * getCollection
      */
     Model.prototype.getBucketName = function () {
-        var _a;
-        return (_a = connection_1.default.Instance) === null || _a === void 0 ? void 0 : _a.getBucket();
+        var bucketName = this.couchbaseConnection().getBucket();
+        if (!bucketName) {
+            throw new Error('couchset is not connected; call couchset(args) first');
+        }
+        return bucketName;
     };
     /** Get this collection
      * getCollection
      */
     Model.prototype.couchbaseConnection = function () {
-        return connection_1.default.Instance;
+        return this.connection || connection_1.default.Instance;
     };
     /** Get this collection
      * getCollection
@@ -124,217 +301,514 @@ var Model = /** @class */ (function () {
         this.fresh();
         return this.collection;
     };
+    Model.prototype.collectionTarget = function () {
+        if (!this.scopeName && !this.collectionTargetName) {
+            return {};
+        }
+        return {
+            scopeName: this.scopeName || '_default',
+            collectionName: this.collectionTargetName || '_default',
+        };
+    };
+    Model.prototype.queryResultKey = function () {
+        var target = this.collectionTarget();
+        return target.collectionName || this.getBucketName();
+    };
+    Model.prototype.readContext = function () {
+        var _this = this;
+        return {
+            bucketName: this.keyspace(),
+            collectionName: this.collectionName,
+            cluster: this.couchbaseConnection().cluster,
+            parse: function (data) { return _this.parse(data); },
+            resultKey: this.queryResultKey(),
+        };
+    };
+    Model.prototype.readArgs = function (args) {
+        if (args === void 0) { args = {}; }
+        return (0, default_scope_1.applyDefaultWhere)(args, {
+            defaultWhere: this.defaultWhere,
+            mode: this.defaultWhereMode,
+            softDelete: this.softDelete,
+        });
+    };
+    Model.prototype.writeContext = function () {
+        var _this = this;
+        return {
+            collection: this.getCollection(),
+            collectionName: this.collectionName,
+            scope: this.scope,
+            parse: function (data) { return _this.parse(data); },
+            serialize: function (data) { return _this.serialize(data); },
+            serializeField: function (path, value) { return _this.serializeField(path, value); },
+            validateCreate: this.validateCreateHook,
+            validateReplace: this.validateReplaceHook,
+        };
+    };
+    Model.prototype.cloneWithDefaultWhereMode = function (mode) {
+        var options = {
+            codecs: this.codecs,
+            dateFields: this.dateFields,
+            defaultWhere: this.defaultWhere,
+            parse: this.parseHook,
+            schema: this.schema,
+            softDelete: this.softDelete,
+            validateCreate: this.validateCreateHook,
+            validateReplace: this.validateReplaceHook,
+        };
+        if (this.scopeName) {
+            options.scope = this.scopeName;
+        }
+        if (this.collectionTargetName) {
+            options.collection = this.collectionTargetName;
+        }
+        var model = new Model(this.collectionName, options, this.connection);
+        model.defaultWhereMode = mode;
+        return model;
+    };
+    /**
+     * Return the active bucket as a SQL++ keyspace identifier.
+     */
+    Model.prototype.bucket = function () {
+        return (0, keyspace_1.bucketIdentifier)(this.getBucketName());
+    };
+    /**
+     * Return this model's SQL++ keyspace target.
+     */
+    Model.prototype.keyspace = function () {
+        var target = this.collectionTarget();
+        return (0, keyspace_1.keyspaceIdentifier)({
+            bucketName: this.getBucketName(),
+            scopeName: target.scopeName,
+            collectionName: target.collectionName,
+        });
+    };
+    /**
+     * Return a SQL++ FROM target for this model's current bucket.
+     */
+    Model.prototype.from = function (alias) {
+        return (0, keyspace_1.fromTarget)(this.keyspace(), alias);
+    };
     /**
-     * create
+     * Return CREATE INDEX statements for this model without executing them.
      */
-    Model.prototype.create = function (data, options) {
+    Model.prototype.indexStatements = function (options) {
+        var _this = this;
+        return this.indexes.map(function (index) { return (0, indexes_1.buildIndexQuery)(_this.keyspace(), index, options); });
+    };
+    /**
+     * Create this model's declared indexes if Couchbase does not already have them.
+     */
+    Model.prototype.ensureIndexes = function (options) {
         return __awaiter(this, void 0, void 0, function () {
-            var id, createdData, error_1;
+            var _this = this;
             return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        this.fresh();
-                        id = (0, uuid_1.generateUUID)();
-                        createdData = __assign(__assign({ id: id }, data), { createdAt: new Date(), updatedAt: new Date(), _type: this.collectionName, _scope: this.scope });
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, this.collection.upsert(createdData.id, createdData, options)];
-                    case 2:
-                        _a.sent();
-                        return [2 /*return*/, (0, utils_1.parseSchema)(this.schema, createdData)];
-                    case 3:
-                        error_1 = _a.sent();
-                        throw error_1;
-                    case 4: return [2 /*return*/];
-                }
+                return [2 /*return*/, this.withConnection(function () {
+                        return (0, indexes_1.ensureModelIndexes)(_this.couchbaseConnection().cluster, _this.keyspace(), _this.indexes, options);
+                    })];
             });
         });
     };
     /**
-     * findById
+     * Run a SQL++ query and return rows directly.
      */
-    Model.prototype.findById = function (id, options) {
+    Model.prototype.queryRows = function (query, params, options) {
         return __awaiter(this, void 0, void 0, function () {
-            var data, error_2;
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.withConnection(function () {
+                        return (0, safe_query_1.runQueryRows)(_this.couchbaseConnection().cluster, query, params, options);
+                    })];
+            });
+        });
+    };
+    /**
+     * Run a SQL++ query and return the first row or null.
+     */
+    Model.prototype.queryOne = function (query, params, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.withConnection(function () {
+                        return (0, safe_query_1.runQueryOne)(_this.couchbaseConnection().cluster, query, params, options);
+                    })];
+            });
+        });
+    };
+    /**
+     * Run a SQL++ query using limit + 1 pagination.
+     */
+    Model.prototype.queryPage = function (query, params, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.withConnection(function () {
+                        return (0, safe_query_1.runQueryPage)(_this.couchbaseConnection().cluster, query, params, options);
+                    })];
+            });
+        });
+    };
+    /**
+     * Find many model-scoped documents.
+     */
+    Model.prototype.findMany = function () {
+        return __awaiter(this, arguments, void 0, function (args) {
+            var _this = this;
+            if (args === void 0) { args = {}; }
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.withConnection(function () { return (0, read_helpers_1.findMany)(_this.readContext(), _this.readArgs(args)); })];
+            });
+        });
+    };
+    /**
+     * Find the first matching model-scoped document.
+     */
+    Model.prototype.findOne = function () {
+        return __awaiter(this, arguments, void 0, function (args) {
+            var _this = this;
+            if (args === void 0) { args = {}; }
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.withConnection(function () { return (0, read_helpers_1.findOne)(_this.readContext(), _this.readArgs(args)); })];
+            });
+        });
+    };
+    /**
+     * Check whether at least one model-scoped document matches.
+     */
+    Model.prototype.exists = function () {
+        return __awaiter(this, arguments, void 0, function (args) {
+            var _this = this;
+            if (args === void 0) { args = {}; }
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.withConnection(function () { return (0, read_helpers_1.exists)(_this.readContext(), _this.readArgs(args)); })];
+            });
+        });
+    };
+    /**
+     * Count model-scoped documents.
+     */
+    Model.prototype.count = function () {
+        return __awaiter(this, arguments, void 0, function (args) {
+            var _this = this;
+            if (args === void 0) { args = {}; }
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.withConnection(function () { return (0, read_helpers_1.count)(_this.readContext(), _this.readArgs(args)); })];
+            });
+        });
+    };
+    /**
+     * Fetch a limit + 1 page of model-scoped documents.
+     */
+    Model.prototype.page = function () {
+        return __awaiter(this, arguments, void 0, function (args) {
+            var _this = this;
+            if (args === void 0) { args = {}; }
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.withConnection(function () { return (0, read_helpers_1.page)(_this.readContext(), _this.readArgs(args)); })];
+            });
+        });
+    };
+    Model.prototype.withDeleted = function () {
+        return this.cloneWithDefaultWhereMode('withDeleted');
+    };
+    Model.prototype.onlyDeleted = function () {
+        return this.cloneWithDefaultWhereMode('onlyDeleted');
+    };
+    Model.prototype.withoutDefaultWhere = function () {
+        return this.cloneWithDefaultWhereMode('none');
+    };
+    /**
+     * Insert a new document and fail if the id already exists.
+     */
+    Model.prototype.insert = function (data, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.withConnection(function () { return (0, write_helpers_1.insert)(_this.writeContext(), data, options); })];
+            });
+        });
+    };
+    /** @internal Prepare a transaction insert without issuing a normal SDK write. */
+    Model.prototype.prepareInsert = function (data) {
+        return (0, write_helpers_1.prepareInsertDocument)(this.writeContext(), data);
+    };
+    /**
+     * Explicit insert-or-replace write.
+     */
+    Model.prototype.upsert = function (data, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.withConnection(function () { return (0, write_helpers_1.upsert)(_this.writeContext(), data, options); })];
+            });
+        });
+    };
+    Model.prototype.getById = function (id, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.withConnection(function () { return __awaiter(_this, void 0, void 0, function () {
+                        var data;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4 /*yield*/, this.collection.get(id, options)];
+                                case 1:
+                                    data = _a.sent();
+                                    return [2 /*return*/, this.parse(data.content)];
+                            }
+                        });
+                    }); })];
+            });
+        });
+    };
+    Model.prototype.findDocById = function (id, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var data;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0:
-                        this.fresh();
-                        _a.label = 1;
+                    case 0: return [4 /*yield*/, this.getById(id, options)];
                     case 1:
-                        _a.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, this.collection.get(id, options)];
-                    case 2:
                         data = _a.sent();
-                        return [2 /*return*/, (0, utils_1.parseSchema)(this.schema, data.content)];
-                    case 3:
-                        error_2 = _a.sent();
-                        throw error_2;
-                    case 4: return [2 /*return*/];
+                        return [2 /*return*/, this.hydrate(data)];
                 }
             });
         });
     };
     /**
-     * update
+     * Find a document with SDK metadata.
      */
-    Model.prototype.updateById = function (id, data, opt) {
+    Model.prototype.findByIdWithMeta = function (id, options) {
         return __awaiter(this, void 0, void 0, function () {
-            var _a, _b, silent, options, updatedDocument, error_3;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        this.fresh();
-                        _a = opt || {}, _b = _a.silent, silent = _b === void 0 ? false : _b, options = __rest(_a, ["silent"]);
-                        updatedDocument = __assign(__assign({}, data), { id: id, _type: this.collectionName, _scope: this.scope });
-                        if (!silent) {
-                            updatedDocument.updatedAt = new Date();
-                        }
-                        _c.label = 1;
-                    case 1:
-                        _c.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, this.collection.replace(id, updatedDocument, options)];
-                    case 2:
-                        _c.sent();
-                        return [2 /*return*/, (0, utils_1.parseSchema)(this.schema, updatedDocument)];
-                    case 3:
-                        error_3 = _c.sent();
-                        throw error_3;
-                    case 4: return [2 /*return*/];
-                }
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.withConnection(function () { return (0, write_helpers_1.findByIdWithMeta)(_this.writeContext(), id, options); })];
+            });
+        });
+    };
+    /** Ergonomic alias for findByIdWithMeta, intended for CAS workflows. */
+    Model.prototype.getWithCas = function (id, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.findByIdWithMeta(id, options)];
             });
         });
     };
     /**
-     * save
+     * Explicit full-document replace.
      */
-    Model.prototype.save = function (data, opt) {
+    Model.prototype.replaceById = function (id, data, options) {
         return __awaiter(this, void 0, void 0, function () {
-            var id, _a, _b, silent, options, updatedDocument, error_4;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        this.fresh();
-                        id = data && data.id;
-                        _a = opt || {}, _b = _a.silent, silent = _b === void 0 ? false : _b, options = __rest(_a, ["silent"]);
-                        updatedDocument = __assign(__assign({}, data), { id: id, _type: this.collectionName, _scope: this.scope });
-                        if (!silent) {
-                            updatedDocument.updatedAt = new Date();
-                        }
-                        _c.label = 1;
-                    case 1:
-                        _c.trys.push([1, 3, , 4]);
-                        if (!id) {
-                            throw new Error('document must have id');
-                        }
-                        return [4 /*yield*/, this.collection.replace(id, updatedDocument, options)];
-                    case 2:
-                        _c.sent();
-                        return [2 /*return*/, (0, utils_1.parseSchema)(this.schema, updatedDocument)];
-                    case 3:
-                        error_4 = _c.sent();
-                        console.error(error_4);
-                        throw error_4;
-                    case 4: return [2 /*return*/];
-                }
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.withConnection(function () {
+                        return (0, write_helpers_1.replaceById)(_this.writeContext(), id, data, options);
+                    })];
             });
         });
     };
-    Model.prototype.delete = function (id, options) {
+    /** @internal Prepare a transaction replace without issuing a normal SDK write. */
+    Model.prototype.prepareReplace = function (id, data, options) {
+        return (0, write_helpers_1.prepareReplacementDocument)(this.writeContext(), id, data, options);
+    };
+    /**
+     * Replace only when the supplied CAS still describes the current document.
+     * CouchSet deliberately performs one SDK operation and never re-reads/retries
+     * with a new CAS, because doing so would defeat the caller's concurrency check.
+     */
+    Model.prototype.replaceIfCas = function (id, data, cas, options) {
         return __awaiter(this, void 0, void 0, function () {
-            var error_5;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.replaceById(id, data, __assign(__assign({}, (options || {})), { cas: cas }))];
+            });
+        });
+    };
+    /**
+     * Remove a one-time document with exactly the CAS supplied by the caller.
+     * Missing and CAS-mismatch cases are normal outcomes; transport and ambiguous
+     * failures are rethrown so callers never mistake an unknown commit for success.
+     */
+    Model.prototype.consumeOnce = function (id, cas) {
+        return __awaiter(this, void 0, void 0, function () {
+            var error_2, name_1, message;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0:
-                        this.fresh();
-                        _a.label = 1;
+                    case 0: return [4 /*yield*/, this.prepare()];
                     case 1:
-                        _a.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, this.collection.remove(id, options)];
-                    case 2:
                         _a.sent();
-                        return [2 /*return*/, true];
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, 4, , 5]);
+                        return [4 /*yield*/, this.collection.remove(id, { cas: cas })];
                     case 3:
-                        error_5 = _a.sent();
-                        throw error_5;
-                    case 4: return [2 /*return*/];
+                        _a.sent();
+                        return [2 /*return*/, { status: 'consumed' }];
+                    case 4:
+                        error_2 = _a.sent();
+                        name_1 = (error_2 === null || error_2 === void 0 ? void 0 : error_2.name) || '';
+                        message = (error_2 === null || error_2 === void 0 ? void 0 : error_2.message) || '';
+                        if (/DocumentNotFound|not found/i.test("".concat(name_1, " ").concat(message))) {
+                            return [2 /*return*/, { status: 'missing' }];
+                        }
+                        if (/CasMismatch|cas mismatch/i.test("".concat(name_1, " ").concat(message))) {
+                            return [2 /*return*/, { status: 'conflict' }];
+                        }
+                        throw error_2;
+                    case 5: return [2 /*return*/];
                 }
             });
         });
     };
     /**
-     * Pagination
-     *
-        select = ['id', 'createdAt']
-        where = {
-         where: { owner: { $eq: "stoqey" }, _type: { $eq: "Trade" } },
-        },
-        page = 0,
-        limit = 10,
-        orderBy = { createdAt: "DESC" },
-    * @param args PaginationArgs
-    */
-    Model.prototype.pagination = function (_a) {
-        return __awaiter(this, arguments, void 0, function (_b) {
-            var whereEx, bucketName, rows;
+     * Partial document mutation using common patch operators.
+     */
+    Model.prototype.patchById = function (id, patch, options) {
+        return __awaiter(this, void 0, void 0, function () {
             var _this = this;
-            var select = _b.select, where = _b.where, orderBy = _b.orderBy, limit = _b.limit, page = _b.page, _c = _b.customQuery, customQuery = _c === void 0 ? {} : _c;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        this.fresh(); // refresh
-                        whereEx = { _type: { $eq: this.collectionName } };
-                        if (where) {
-                            whereEx = __assign(__assign({}, whereEx), where);
-                        }
-                        bucketName = connection_1.default.Instance.bucketName;
-                        return [4 /*yield*/, (0, pagination_1.Pagination)({
-                                bucketName: bucketName,
-                                select: select,
-                                where: __assign({ where: whereEx }, customQuery),
-                                limit: limit,
-                                page: page,
-                                orderBy: orderBy,
-                            })];
-                    case 1:
-                        rows = _d.sent();
-                        return [2 /*return*/, rows.map(function (r) { return (0, utils_1.parseSchema)(_this.schema, r); })];
-                }
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.withConnection(function () {
+                        return (0, write_helpers_1.patchById)(_this.writeContext(), id, patch, options);
+                    })];
             });
         });
     };
     /**
-     * Run a custom query with model parsing
-     * @param { select, query }
-     * @returns
+     * Couchbase subdocument mutation escape hatch.
      */
-    Model.prototype.customQuery = function (_a) {
-        return __awaiter(this, arguments, void 0, function (_b) {
-            var response;
-            var params = _b.params, limit = _b.limit, query = _b.query;
+    Model.prototype.mutateById = function (id, specs, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.withConnection(function () {
+                        return (0, write_helpers_1.mutateById)(_this.writeContext(), id, specs, options);
+                    })];
+            });
+        });
+    };
+    /**
+     * Atomic numeric field increment.
+     */
+    Model.prototype.incrementById = function (id, field, delta, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.withConnection(function () {
+                        return (0, write_helpers_1.incrementById)(_this.writeContext(), id, field, delta, options);
+                    })];
+            });
+        });
+    };
+    Model.prototype.softDeleteById = function (id, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.patchById(id, { $set: { deleted: true, deletedAt: new Date() } }, options)];
+            });
+        });
+    };
+    Model.prototype.restoreById = function (id, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.patchById(id, { $unset: ['deleted', 'deletedAt'] }, options)];
+            });
+        });
+    };
+    Model.prototype.deleteById = function (id, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _b, hard, removeOptions;
+            var _this = this;
             return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        this.fresh(); // refresh
-                        return [4 /*yield*/, (0, search_1.CustomQuery)({
-                                limit: limit,
-                                params: params,
-                                query: query,
-                            })];
+                _a = options || {}, _b = _a.hard, hard = _b === void 0 ? false : _b, removeOptions = __rest(_a, ["hard"]);
+                if (hard || !this.softDelete) {
+                    return [2 /*return*/, this.withConnection(function () { return __awaiter(_this, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, this.collection.remove(id, removeOptions)];
+                                    case 1:
+                                        _a.sent();
+                                        return [2 /*return*/, true];
+                                }
+                            });
+                        }); })];
+                }
+                return [2 /*return*/, this.softDeleteById(id)];
+            });
+        });
+    };
+    Model.prototype.findDocOne = function () {
+        return __awaiter(this, arguments, void 0, function (args) {
+            var data;
+            if (args === void 0) { args = {}; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.findOne(args)];
                     case 1:
-                        response = _c.sent();
-                        return [2 /*return*/, response];
+                        data = _a.sent();
+                        return [2 /*return*/, data ? this.hydrate(data) : null];
                 }
             });
         });
     };
+    Model.prototype.hydrate = function (data) {
+        return (0, hydrated_document_1.hydrate)(this, this.parse(data));
+    };
     Model.prototype.parse = function (data) {
-        this.fresh(); // refresh
-        return (0, utils_1.parseSchema)(this.schema, data);
+        var decoded = this.deserialize(data);
+        var parsed = (0, utils_1.parseSchema)(this.schema, decoded);
+        var parsedDates = (0, validation_1.parseDateFields)(parsed, this.dateFields);
+        return this.parseHook ? this.parseHook(parsedDates) : parsedDates;
+    };
+    /** @internal Used by the typed client before a document reaches the SDK. */
+    Model.prototype.serialize = function (data) {
+        var _this = this;
+        var result = __assign({}, data);
+        Object.keys(this.codecs).forEach(function (path) {
+            var current = getPath(result, path);
+            if (current !== undefined) {
+                setPath(result, path, _this.codecs[path].toDatabase(current));
+            }
+        });
+        return result;
+    };
+    /** @internal Used by patch helpers and transaction-bound models. */
+    Model.prototype.serializeField = function (path, value) {
+        return this.codecs[path] ? this.codecs[path].toDatabase(value) : value;
     };
+    Model.prototype.deserialize = function (data) {
+        var _this = this;
+        var result = __assign({}, data);
+        Object.keys(this.codecs).forEach(function (path) {
+            var current = getPath(result, path);
+            if (current !== undefined) {
+                setPath(result, path, _this.codecs[path].fromDatabase(current));
+            }
+        });
+        return result;
+    };
+    Model.registeredModels = [];
     return Model;
 }());
 exports.Model = Model;
+var getPath = function (data, path) {
+    return path.split('.').reduce(function (value, key) { return (value == null ? undefined : value[key]); }, data);
+};
+var setPath = function (data, path, value) {
+    var parts = path.split('.');
+    var key = parts.pop();
+    var target = parts.reduce(function (current, part) {
+        var existing = current[part];
+        if (Array.isArray(existing)) {
+            current[part] = existing.slice();
+        }
+        else if (existing && typeof existing === 'object') {
+            // serialize/parse start with a shallow root copy. Clone every branch
+            // we traverse so dotted codecs never mutate caller or SDK content.
+            current[part] = __assign({}, existing);
+        }
+        else {
+            current[part] = {};
+        }
+        return current[part];
+    }, data);
+    target[key] = value;
+};
 exports.default = Model;
 //# sourceMappingURL=index.js.map