@decaf-ts/for-couchdb 0.1.29 → 0.2.0

package/dist/for-couchdb.cjs

@@ -0,0 +1,872 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@decaf-ts/core'), require('@decaf-ts/db-decorators'), require('@decaf-ts/decorator-validation'), require('reflect-metadata')) :
+    typeof define === 'function' && define.amd ? define(['exports', '@decaf-ts/core', '@decaf-ts/db-decorators', '@decaf-ts/decorator-validation', 'reflect-metadata'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["for-couchdb"] = {}, global.core, global.dbDecorators, global.decoratorValidation));
+})(this, (function (exports, core, dbDecorators, decoratorValidation) { 'use strict';
+
+    const reservedAttributes = /^_.*$/g;
+    const CouchDBKeys = {
+        SEPARATOR: "_",
+        ID: "_id",
+        REV: "_rev",
+        DELETED: "_deleted",
+        TABLE: "??table",
+        SEQUENCE: "??sequence",
+        DDOC: "ddoc",
+        NATIVE: "__native",
+        INDEX: "index",
+    };
+
+    const CouchDBOperator = {
+        EQUAL: "$eq",
+        DIFFERENT: "$ne",
+        BIGGER: "$gt",
+        BIGGER_EQ: "$gte",
+        SMALLER: "$lt",
+        SMALLER_EQ: "$lte",
+        // BETWEEN = "BETWEEN",
+        NOT: "$not",
+        IN: "$in",
+        // IS = "IS",
+        REGEXP: "$regex",
+    };
+    const CouchDBGroupOperator = {
+        AND: "$and",
+        OR: "$or",
+    };
+
+    function generateIndexName$1(name, direction, compositions, separator = dbDecorators.DefaultSeparator) {
+        return [
+            ...name.map((n) => (n === CouchDBKeys.TABLE ? "table" : n)),
+            ...([]),
+            ...([]),
+            CouchDBKeys.INDEX,
+        ].join(separator);
+    }
+    function generateIndexes(models) {
+        const tableName = generateIndexName$1([CouchDBKeys.TABLE]);
+        const indexes = {};
+        indexes[tableName] = {
+            index: {
+                fields: [CouchDBKeys.TABLE],
+            },
+            name: tableName,
+            ddoc: tableName,
+            type: "json",
+        };
+        models.forEach((m) => {
+            const ind = core.Repository.indexes(m);
+            Object.entries(ind).forEach(([key, value]) => {
+                const k = Object.keys(value)[0];
+                // eslint-disable-next-line prefer-const
+                let { directions, compositions } = value[k];
+                const tableName = core.Repository.table(m);
+                compositions = compositions || [];
+                function generate(sort) {
+                    const name = [
+                        tableName,
+                        key,
+                        ...compositions,
+                        core.PersistenceKeys.INDEX,
+                    ].join(dbDecorators.DefaultSeparator);
+                    indexes[name] = {
+                        index: {
+                            fields: [key, ...compositions, CouchDBKeys.TABLE].reduce((accum, el) => {
+                                if (sort) {
+                                    const res = {};
+                                    res[el] = sort;
+                                    accum.push(res);
+                                }
+                                else {
+                                    accum.push(el);
+                                }
+                                return accum;
+                            }, []),
+                        },
+                        name: name,
+                        ddoc: name,
+                        type: "json",
+                    };
+                    if (!sort) {
+                        const tableFilter = {};
+                        tableFilter[CouchDBKeys.TABLE] = {};
+                        tableFilter[CouchDBKeys.TABLE][CouchDBOperator.EQUAL] = tableName;
+                        indexes[name].index.partial_filter_selector = tableFilter;
+                    }
+                }
+                generate();
+                if (directions)
+                    directions.forEach((d) => generate(d));
+            });
+        });
+        return Object.values(indexes);
+    }
+
+    /******************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */
+    /* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+    function __decorate(decorators, target, key, desc) {
+        var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+        if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+        else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+        return c > 3 && r && Object.defineProperty(target, key, r), r;
+    }
+
+    function __metadata(metadataKey, metadataValue) {
+        if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
+    }
+
+    typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+        var e = new Error(message);
+        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+    };
+
+    exports.Sequence = class Sequence extends core.BaseModel {
+        constructor(seq) {
+            super(seq);
+        }
+    };
+    __decorate([
+        core.pk(),
+        __metadata("design:type", String)
+    ], exports.Sequence.prototype, "id", void 0);
+    __decorate([
+        decoratorValidation.required(),
+        core.index(),
+        __metadata("design:type", Object)
+    ], exports.Sequence.prototype, "current", void 0);
+    exports.Sequence = __decorate([
+        core.table(CouchDBKeys.SEQUENCE),
+        decoratorValidation.model(),
+        __metadata("design:paramtypes", [Object])
+    ], exports.Sequence);
+
+    function parseSequenceValue(type, value) {
+        switch (type) {
+            case "Number":
+                return typeof value === "string"
+                    ? parseInt(value)
+                    : typeof value === "number"
+                        ? value
+                        : BigInt(value);
+            case "BigInt":
+                return BigInt(value);
+            default:
+                throw new dbDecorators.InternalError("Should never happen");
+        }
+    }
+
+    /**
+     * @summary Abstract implementation of a Sequence
+     * @description provides the basic functionality for {@link Sequence}s
+     *
+     * @param {SequenceOptions} options
+     *
+     * @class CouchDBSequence
+     * @implements Sequence
+     *
+     * @category Sequences
+     */
+    class CouchDBSequence extends core.Sequence {
+        constructor(options, adapter) {
+            super(options);
+            this.repo = core.Repository.forModel(exports.Sequence, adapter.flavour);
+        }
+        /**
+         * @summary Retrieves the current value for the sequence
+         * @protected
+         */
+        async current() {
+            const { name, startWith } = this.options;
+            try {
+                const sequence = await this.repo.read(name);
+                return this.parse(sequence.current);
+            }
+            catch (e) {
+                if (e instanceof dbDecorators.NotFoundError) {
+                    if (typeof startWith === "undefined")
+                        throw new dbDecorators.InternalError("Starting value is not defined for a non existing sequence");
+                    try {
+                        return this.parse(startWith);
+                    }
+                    catch (e) {
+                        throw new dbDecorators.InternalError(decoratorValidation.sf("Failed to parse initial value for sequence {0}: {1}", startWith.toString(), e));
+                    }
+                }
+                throw new dbDecorators.InternalError(decoratorValidation.sf("Failed to retrieve current value for sequence {0}: {1}", name, e));
+            }
+        }
+        /**
+         * @summary Parses the {@link Sequence} value
+         *
+         * @protected
+         * @param value
+         */
+        parse(value) {
+            return parseSequenceValue(this.options.type, value);
+        }
+        /**
+         * @summary increments the sequence
+         * @description Sequence specific implementation
+         *
+         * @param {string | number | bigint} current
+         * @param count
+         * @protected
+         */
+        async increment(current, count) {
+            const { type, incrementBy, name } = this.options;
+            let next;
+            const toIncrementBy = count || incrementBy;
+            if (toIncrementBy % incrementBy !== 0)
+                throw new dbDecorators.InternalError(`Value to increment does not consider the incrementBy setting: ${incrementBy}`);
+            switch (type) {
+                case "Number":
+                    next = this.parse(current) + toIncrementBy;
+                    break;
+                case "BigInt":
+                    next = this.parse(current) + BigInt(toIncrementBy);
+                    break;
+                default:
+                    throw new dbDecorators.InternalError("Should never happen");
+            }
+            let seq;
+            try {
+                seq = await this.repo.update(new exports.Sequence({ id: name, current: next }));
+            }
+            catch (e) {
+                if (!(e instanceof dbDecorators.NotFoundError))
+                    throw e;
+                seq = await this.repo.create(new exports.Sequence({ id: name, current: next }));
+            }
+            return seq.current;
+        }
+        /**
+         * @summary Generates the next value in th sequence
+         * @description calls {@link Sequence#parse} on the current value
+         * followed by {@link Sequence#increment}
+         *
+         */
+        async next() {
+            const current = await this.current();
+            return this.increment(current);
+        }
+        async range(count) {
+            const current = (await this.current());
+            const incrementBy = this.parse(this.options.incrementBy);
+            const next = await this.increment(current, this.parse(count) * incrementBy);
+            const range = [];
+            for (let i = 1; i <= count; i++) {
+                range.push(current + incrementBy * this.parse(i));
+            }
+            if (range[range.length - 1] !== next)
+                throw new dbDecorators.InternalError("Miscalculation of range");
+            return range;
+        }
+    }
+
+    class CouchDBPaginator extends core.Paginator {
+        get total() {
+            throw new dbDecorators.InternalError(`The total pages api is not available for couchdb`);
+        }
+        get count() {
+            throw new dbDecorators.InternalError(`The record count api is not available for couchdb`);
+        }
+        constructor(statement, size, rawStatement) {
+            super(statement, size, rawStatement);
+        }
+        prepare(rawStatement) {
+            const query = Object.assign({}, rawStatement);
+            if (query.limit)
+                this.limit = query.limit;
+            query.limit = this.size;
+            return query;
+        }
+        async page(page = 1, ...args) {
+            const statement = Object.assign({}, this.statement);
+            const target = this.stat.getTarget();
+            // if (!this._recordCount || !this._totalPages) {
+            //   // this._recordCount = await this.adapter
+            //   //   .Query()
+            //   //   .count()
+            //   //   .from(target)
+            //   //   .execute<number>();
+            // }
+            if (page !== 1) {
+                if (!this.bookMark)
+                    throw new core.PagingError("No bookmark. Did you start in the first page?");
+                statement["bookmark"] = this.bookMark;
+            }
+            const rawResult = await this.adapter.raw(statement, false, ...args);
+            const { docs, bookmark, warning } = rawResult;
+            if (warning)
+                console.warn(warning);
+            const results = statement.fields && statement.fields.length
+                ? docs // has fields means its not full model
+                : docs.map((d) => {
+                    //no fields means we need to revert to saving process
+                    if (!target)
+                        throw new core.PagingError("No statement target defined");
+                    const pkDef = dbDecorators.findPrimaryKey(new target());
+                    const pk = pkDef.id;
+                    const originalId = d._id.split(dbDecorators.DefaultSeparator);
+                    originalId.splice(0, 1); // remove the table name
+                    return this.adapter.revert(d, target, pk, parseSequenceValue(pkDef.props.type, originalId.join(dbDecorators.DefaultSeparator)));
+                });
+            this.bookMark = bookmark;
+            this._currentPage = page;
+            return results;
+        }
+    }
+
+    class CouchDBStatement extends core.Statement {
+        constructor(adapter) {
+            super(adapter);
+        }
+        /**
+         * @inheritDoc
+         */
+        async execute() {
+            try {
+                const query = this.build();
+                if (!query.limit)
+                    query.limit = Number.MAX_SAFE_INTEGER;
+                return this.raw(query);
+            }
+            catch (e) {
+                throw new dbDecorators.InternalError(e);
+            }
+        }
+        async paginate(size) {
+            try {
+                const query = this.build();
+                return new CouchDBPaginator(this, size, query);
+            }
+            catch (e) {
+                throw new dbDecorators.InternalError(e);
+            }
+        }
+        processRecord(r, pkAttr, sequenceType) {
+            if (!r[CouchDBKeys.ID])
+                throw new dbDecorators.InternalError(`No CouchDB Id definition found. Should not be possible`);
+            const [, ...keyArgs] = r[CouchDBKeys.ID].split("_");
+            const id = keyArgs.join("_");
+            return this.adapter.revert(r, this.target, pkAttr, parseSequenceValue(sequenceType, id));
+        }
+        async raw(rawInput, ...args) {
+            const results = await this.adapter.raw(rawInput, true, ...args);
+            if (!this.fullRecord)
+                return results;
+            if (!this.target)
+                throw new dbDecorators.InternalError("No target defined in statement. should never happen");
+            const pkDef = dbDecorators.findPrimaryKey(new this.target());
+            const pkAttr = pkDef.id;
+            const type = pkDef.props.type;
+            if (Array.isArray(results))
+                return results.map((r) => this.processRecord(r, pkAttr, type));
+            return this.processRecord(results, pkAttr, type);
+        }
+    }
+
+    // noinspection JSAnnotator
+    class CouchDBFromClause extends core.FromClause {
+        constructor(clause) {
+            super(clause);
+        }
+        build(previous) {
+            const selectors = {};
+            selectors[CouchDBKeys.TABLE] = {};
+            selectors[CouchDBKeys.TABLE] =
+                typeof this.selector === "string"
+                    ? this.selector
+                    : core.Repository.table(this.selector);
+            previous.selector = selectors;
+            return previous;
+        }
+    }
+
+    // noinspection JSAnnotator
+    class CouchDBInsertClause extends core.InsertClause {
+        constructor(clause) {
+            super(clause);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        build(query) {
+            throw new dbDecorators.InternalError("Not supported");
+        }
+    }
+
+    class CouchDBWhereClause extends core.WhereClause {
+        constructor(clause) {
+            super(clause);
+        }
+        build(query) {
+            const condition = this.adapter.parseCondition(core.Condition.and(this.condition, core.Condition.attribute(CouchDBKeys.TABLE).eq(query.selector[CouchDBKeys.TABLE]))).selector;
+            const selectorKeys = Object.keys(condition);
+            if (selectorKeys.length === 1 &&
+                Object.values(CouchDBGroupOperator).indexOf(selectorKeys[0]) !== -1)
+                switch (selectorKeys[0]) {
+                    case CouchDBGroupOperator.AND:
+                        condition[CouchDBGroupOperator.AND] = [
+                            ...Object.values(condition[CouchDBGroupOperator.AND]).reduce((accum, val) => {
+                                const keys = Object.keys(val);
+                                if (keys.length !== 1)
+                                    throw new Error("Too many keys in query selector. should be one");
+                                const k = keys[0];
+                                if (k === CouchDBGroupOperator.AND)
+                                    accum.push(...val[k]);
+                                else
+                                    accum.push(val);
+                                return accum;
+                            }, []),
+                        ];
+                        query.selector = condition;
+                        break;
+                    case CouchDBGroupOperator.OR: {
+                        const s = {};
+                        s[CouchDBGroupOperator.AND] = [
+                            condition,
+                            ...Object.entries(query.selector).map(([key, val]) => {
+                                const result = {};
+                                result[key] = val;
+                                return result;
+                            }),
+                        ];
+                        query.selector = s;
+                        break;
+                    }
+                    default:
+                        throw new Error("This should be impossible");
+                }
+            else {
+                Object.entries(condition).forEach(([key, val]) => {
+                    if (query.selector[key])
+                        console.warn(decoratorValidation.sf("A {0} query param is about to be overridden: {1} by {2}", key, query.selector[key], val));
+                    query.selector[key] = val;
+                });
+            }
+            return query;
+        }
+    }
+
+    class CouchDBSelectClause extends core.SelectClause {
+        constructor(clause) {
+            super(clause);
+        }
+        build(query) {
+            if (!this.selector || this.selector === core.Const.FULL_RECORD)
+                return query;
+            query.fields =
+                typeof this.selector === "string"
+                    ? [this.selector]
+                    : this.selector;
+            return query;
+        }
+    }
+
+    class CouchDBValuesClause extends core.ValuesClause {
+        constructor(clause) {
+            super(clause);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        build(previous) {
+            throw new dbDecorators.InternalError("Not implemented");
+        }
+    }
+
+    class Factory extends core.ClauseFactory {
+        constructor(adapter) {
+            super(adapter);
+        }
+        from(statement, selector) {
+            return new CouchDBFromClause({ statement: statement, selector: selector });
+        }
+        groupBy(statement, selector) {
+            return new (class extends core.GroupByClause {
+                constructor(clause) {
+                    super(clause);
+                }
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                build(query) {
+                    throw new dbDecorators.InternalError("Not implemented");
+                }
+            })({
+                statement: statement,
+                selector: selector,
+            });
+        }
+        insert() {
+            return new CouchDBInsertClause({
+                statement: new CouchDBStatement(this.adapter),
+            });
+        }
+        limit(statement, selector) {
+            return new (class extends core.LimitClause {
+                constructor(clause) {
+                    super(clause);
+                }
+                build(query) {
+                    query.limit = this.selector;
+                    return query;
+                }
+            })({
+                statement: statement,
+                selector: selector,
+            });
+        }
+        offset(statement, selector) {
+            return new (class extends core.OffsetClause {
+                constructor(clause) {
+                    super(clause);
+                }
+                build(query) {
+                    const skip = parseInt(this.selector);
+                    if (isNaN(skip))
+                        throw new core.QueryError("Failed to parse offset");
+                    query.skip = skip;
+                    return query;
+                }
+            })({
+                statement: statement,
+                selector: selector,
+            });
+        }
+        orderBy(statement, selector) {
+            return new (class extends core.OrderByClause {
+                constructor(clause) {
+                    super(clause);
+                }
+                build(query) {
+                    query.sort = query.sort || [];
+                    query.selector = query.selector || {};
+                    this.selector.forEach((s) => {
+                        const [selector, value] = s;
+                        const rec = {};
+                        rec[selector] = value;
+                        query.sort.push(rec);
+                        if (!query.selector[selector]) {
+                            query.selector[selector] = {};
+                            query.selector[selector][CouchDBOperator.BIGGER] = null;
+                        }
+                        // query.fields = query.fields || [];
+                        // query.fields = [...new Set([...query.fields, selector]).keys()]
+                    });
+                    return query;
+                }
+            })({
+                statement: statement,
+                selector: selector,
+            });
+        }
+        select(selector) {
+            return new CouchDBSelectClause({
+                statement: new CouchDBStatement(this.adapter),
+                selector: selector,
+            });
+        }
+        values(statement, values) {
+            return new CouchDBValuesClause({
+                statement: statement,
+                values: values,
+            });
+        }
+        where(statement, condition) {
+            return new CouchDBWhereClause({
+                statement: statement,
+                condition: condition,
+            });
+        }
+    }
+
+    function translateOperators(operator) {
+        for (const operators of [CouchDBOperator, CouchDBGroupOperator]) {
+            const el = Object.keys(operators).find((k) => k === operator);
+            if (el)
+                return operators[el];
+        }
+        throw new core.QueryError(`Could not find adapter translation for operator ${operator}`);
+    }
+
+    class IndexError extends dbDecorators.BaseError {
+        constructor(msg) {
+            super(IndexError.name, msg);
+        }
+    }
+
+    class CouchDBAdapter extends core.Adapter {
+        constructor(scope, flavour) {
+            super(scope, flavour);
+            [this.create, this.createAll, this.update, this.updateAll].forEach((m) => {
+                const name = m.name;
+                dbDecorators.prefixMethod(this, m, this[name + "Prefix"]);
+            });
+        }
+        get Clauses() {
+            if (!this.factory)
+                this.factory = new Factory(this);
+            return this.factory;
+        }
+        Query() {
+            return super.Query();
+        }
+        get Statement() {
+            return new CouchDBStatement(this);
+        }
+        parseCondition(condition) {
+            function merge(op, obj1, obj2) {
+                const result = { selector: {} };
+                result.selector[op] = [obj1, obj2];
+                return result;
+            }
+            const { attr1, operator, comparison } = condition;
+            let op = {};
+            if ([core.GroupOperator.AND, core.GroupOperator.OR, core.Operator.NOT].indexOf(operator) === -1) {
+                op[attr1] = {};
+                op[attr1][translateOperators(operator)] =
+                    comparison;
+            }
+            else if (operator === core.Operator.NOT) {
+                op = this.parseCondition(attr1).selector;
+                op[translateOperators(core.Operator.NOT)] = {};
+                op[translateOperators(core.Operator.NOT)][attr1.attr1] = comparison;
+            }
+            else {
+                const op1 = this.parseCondition(attr1).selector;
+                const op2 = this.parseCondition(comparison).selector;
+                op = merge(translateOperators(operator), op1, op2).selector;
+            }
+            return { selector: op };
+        }
+        async Sequence(options) {
+            return new CouchDBSequence(options, this);
+        }
+        async initialize() {
+            const managedModels = core.Adapter.models(this.flavour);
+            return this.index(...managedModels);
+        }
+        assignMetadata(model, rev) {
+            Object.defineProperty(model, core.PersistenceKeys.METADATA, {
+                enumerable: false,
+                configurable: false,
+                writable: false,
+                value: rev,
+            });
+            return model;
+        }
+        assignMultipleMetadata(models, revs) {
+            models.forEach((m, i) => {
+                core.Repository.setMetadata(m, revs[i]);
+                return m;
+            });
+            return models;
+        }
+        createPrefix(tableName, id, model) {
+            const record = {};
+            record[CouchDBKeys.TABLE] = tableName;
+            record[CouchDBKeys.ID] = this.generateId(tableName, id);
+            Object.assign(record, model);
+            return [tableName, id, record];
+        }
+        createAllPrefix(tableName, ids, models) {
+            if (ids.length !== models.length)
+                throw new dbDecorators.InternalError("Ids and models must have the same length");
+            const records = ids.map((id, count) => {
+                const record = {};
+                record[CouchDBKeys.TABLE] = tableName;
+                record[CouchDBKeys.ID] = this.generateId(tableName, id);
+                Object.assign(record, models[count]);
+                return record;
+            });
+            return [tableName, ids, records];
+        }
+        updatePrefix(tableName, id, model) {
+            const record = {};
+            record[CouchDBKeys.TABLE] = tableName;
+            record[CouchDBKeys.ID] = this.generateId(tableName, id);
+            const rev = model[core.PersistenceKeys.METADATA];
+            if (!rev)
+                throw new dbDecorators.InternalError(`No revision number found for record with id ${id}`);
+            Object.assign(record, model);
+            record[CouchDBKeys.REV] = rev;
+            return [tableName, id, record];
+        }
+        updateAllPrefix(tableName, ids, models) {
+            if (ids.length !== models.length)
+                throw new dbDecorators.InternalError("Ids and models must have the same length");
+            const records = ids.map((id, count) => {
+                const record = {};
+                record[CouchDBKeys.TABLE] = tableName;
+                record[CouchDBKeys.ID] = this.generateId(tableName, id);
+                const rev = models[count][core.PersistenceKeys.METADATA];
+                if (!rev)
+                    throw new dbDecorators.InternalError(`No revision number found for record with id ${id}`);
+                Object.assign(record, models[count]);
+                record[CouchDBKeys.REV] = rev;
+                return record;
+            });
+            return [tableName, ids, records];
+        }
+        generateId(tableName, id) {
+            return [tableName, id].join(CouchDBKeys.SEPARATOR);
+        }
+        parseError(err, reason) {
+            return CouchDBAdapter.parseError(err, reason);
+        }
+        isReserved(attr) {
+            return !!attr.match(reservedAttributes);
+        }
+        static parseError(err, reason) {
+            if (err instanceof dbDecorators.BaseError)
+                return err;
+            let code = "";
+            if (typeof err === "string") {
+                code = err;
+                if (code.match(/already exist|update conflict/g))
+                    return new dbDecorators.ConflictError(code);
+                if (code.match(/missing|deleted/g))
+                    return new dbDecorators.NotFoundError(code);
+            }
+            else if (err.code) {
+                code = err.code;
+                reason = reason || err.message;
+            }
+            else if (err.statusCode) {
+                code = err.statusCode;
+                reason = reason || err.message;
+            }
+            else {
+                code = err.message;
+            }
+            switch (code.toString()) {
+                case "401":
+                case "412":
+                case "409":
+                    return new dbDecorators.ConflictError(reason);
+                case "404":
+                    return new dbDecorators.NotFoundError(reason);
+                case "400":
+                    if (code.toString().match(/No\sindex\sexists/g))
+                        return new IndexError(err);
+                    return new dbDecorators.InternalError(err);
+                default:
+                    if (code.toString().match(/ECONNREFUSED/g))
+                        return new core.ConnectionError(err);
+                    return new dbDecorators.InternalError(err);
+            }
+        }
+    }
+
+    async function reAuth(con, user, pass) {
+        return con.auth(user, pass);
+    }
+    function wrapDocumentScope(con, dbName, user, pass) {
+        const db = con.use(dbName);
+        ["insert", "get", "put", "destroy", "find"].forEach((k) => {
+            const original = db[k];
+            Object.defineProperty(db, k, {
+                enumerable: false,
+                configurable: true,
+                value: async (...args) => {
+                    await reAuth(con, user, pass);
+                    return original.call(db, ...args);
+                },
+            });
+        });
+        Object.defineProperty(db, CouchDBKeys.NATIVE, {
+            enumerable: false,
+            configurable: false,
+            writable: false,
+            value: con,
+        });
+        return db;
+    }
+    function testReservedAttributes(attr) {
+        const regexp = /^_.*$/g;
+        return attr.match(regexp);
+    }
+    function generateIndexName(attribute, tableName, compositions, order, separator = dbDecorators.DefaultSeparator) {
+        const attr = [core.PersistenceKeys.INDEX, tableName, attribute];
+        if (compositions)
+            attr.push(...compositions);
+        if (order)
+            attr.push(order);
+        return attr.join(separator);
+    }
+    function generateIndexDoc(attribute, tableName, compositions, order, separator = dbDecorators.DefaultSeparator) {
+        const partialFilterSelector = {};
+        partialFilterSelector[CouchDBKeys.TABLE] = {};
+        partialFilterSelector[CouchDBKeys.TABLE][CouchDBOperator.EQUAL] = tableName;
+        let fields;
+        if (order) {
+            const orderProp = {};
+            orderProp[attribute] = order;
+            const sortedCompositions = (compositions || []).map((c) => {
+                const r = {};
+                r[c] = order;
+                return r;
+            });
+            const sortedTable = {};
+            sortedTable[CouchDBKeys.TABLE] = order;
+            fields = [orderProp, ...sortedCompositions, sortedTable];
+        }
+        else {
+            fields = [attribute, ...(compositions || []), CouchDBKeys.TABLE];
+        }
+        const name = generateIndexName(attribute, tableName, compositions, order, separator);
+        return {
+            index: {
+                fields: fields,
+                // partial_filter_selector: partialFilterSelector,
+            },
+            ddoc: [name, CouchDBKeys.DDOC].join(separator),
+            name: name,
+        };
+    }
+
+    /**
+     * @summary Module summary
+     * @description Module description
+     * @module ts-workspace
+     */
+    /**
+     * @summary Namespace summary
+     * @description Namespace description
+     * @namespace Namespace
+     * @memberOf module:ts-workspace
+     */
+    /**
+     * @summary stores the current package version
+     * @description this is how you should document a constant
+     * @const VERSION
+     * @memberOf module:ts-workspace
+     */
+    const VERSION = "0.2.0";
+
+    exports.CouchDBAdapter = CouchDBAdapter;
+    exports.CouchDBKeys = CouchDBKeys;
+    exports.CouchDBSequence = CouchDBSequence;
+    exports.IndexError = IndexError;
+    exports.VERSION = VERSION;
+    exports.generateIndexDoc = generateIndexDoc;
+    exports.generateIndexName = generateIndexName;
+    exports.generateIndexes = generateIndexes;
+    exports.reAuth = reAuth;
+    exports.reservedAttributes = reservedAttributes;
+    exports.testReservedAttributes = testReservedAttributes;
+    exports.wrapDocumentScope = wrapDocumentScope;
+
+}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"for-couchdb.cjs","sources":["../src/constants.ts","../src/query/constants.ts","../src/indexes/generator.ts","../node_modules/tslib/tslib.es6.js","../src/model/CouchDBSequence.ts","../src/sequences/utils.ts","../src/sequences/Sequence.ts","../src/query/Paginator.ts","../src/query/Statement.ts","../src/query/FromClause.ts","../src/query/InsertClause.ts","../src/query/WhereClause.ts","../src/query/SelectClause.ts","../src/query/ValuesClause.ts","../src/query/factory.ts","../src/query/translate.ts","../src/errors.ts","../src/adapter.ts","../src/utils.ts","../src/index.ts"],"sourcesContent":["export const reservedAttributes = /^_.*$/g;\n\nexport const CouchDBKeys = {\n  SEPARATOR: \"_\",\n  ID: \"_id\",\n  REV: \"_rev\",\n  DELETED: \"_deleted\",\n  TABLE: \"??table\",\n  SEQUENCE: \"??sequence\",\n  DDOC: \"ddoc\",\n  NATIVE: \"__native\",\n  INDEX: \"index\",\n};\n","import { MangoOperator } from \"../types\";\n\nexport const CouchDBOperator: Record<string, MangoOperator> = {\n  EQUAL: \"$eq\",\n  DIFFERENT: \"$ne\",\n  BIGGER: \"$gt\",\n  BIGGER_EQ: \"$gte\",\n  SMALLER: \"$lt\",\n  SMALLER_EQ: \"$lte\",\n  // BETWEEN = \"BETWEEN\",\n  NOT: \"$not\",\n  IN: \"$in\",\n  // IS = \"IS\",\n  REGEXP: \"$regex\",\n};\n\nexport const CouchDBGroupOperator: Record<string, MangoOperator> = {\n  AND: \"$and\",\n  OR: \"$or\",\n};\n\nexport const CouchDBConst: Record<string, string> = {\n  NULL: \"null\",\n};\n","import {\n  IndexMetadata,\n  OrderDirection,\n  PersistenceKeys,\n  Repository,\n} from \"@decaf-ts/core\";\nimport { CouchDBKeys } from \"../constants\";\nimport { DefaultSeparator } from \"@decaf-ts/db-decorators\";\nimport { Constructor, Model } from \"@decaf-ts/decorator-validation\";\nimport { CouchDBOperator } from \"../query/constants\";\nimport { CreateIndexRequest } from \"../types\";\n\nfunction generateIndexName(\n  name: string[],\n  direction?: OrderDirection,\n  compositions?: string[],\n  separator = DefaultSeparator\n) {\n  return [\n    ...name.map((n) => (n === CouchDBKeys.TABLE ? \"table\" : n)),\n    ...(compositions || []),\n    ...(direction ? [direction] : []),\n    CouchDBKeys.INDEX,\n  ].join(separator);\n}\n\nexport function generateIndexes<M extends Model>(\n  models: Constructor<M>[]\n): CreateIndexRequest[] {\n  const tableName = generateIndexName([CouchDBKeys.TABLE]);\n  const indexes: Record<string, CreateIndexRequest> = {};\n  indexes[tableName] = {\n    index: {\n      fields: [CouchDBKeys.TABLE],\n    },\n    name: tableName,\n    ddoc: tableName,\n    type: \"json\",\n  };\n\n  models.forEach((m) => {\n    const ind: Record<string, IndexMetadata> = Repository.indexes(m);\n    Object.entries(ind).forEach(([key, value]) => {\n      const k = Object.keys(value)[0];\n      // eslint-disable-next-line prefer-const\n      let { directions, compositions } = (value as any)[k];\n      const tableName = Repository.table(m);\n      compositions = compositions || [];\n\n      function generate(sort?: OrderDirection) {\n        const name = [\n          tableName,\n          key,\n          ...(compositions as []),\n          PersistenceKeys.INDEX,\n        ].join(DefaultSeparator);\n\n        indexes[name] = {\n          index: {\n            fields: [key, ...(compositions as []), CouchDBKeys.TABLE].reduce(\n              (accum: any[], el) => {\n                if (sort) {\n                  const res: any = {};\n                  res[el] = sort;\n                  accum.push(res);\n                } else {\n                  accum.push(el);\n                }\n                return accum;\n              },\n              []\n            ),\n          },\n          name: name,\n          ddoc: name,\n          type: \"json\",\n        };\n        if (!sort) {\n          const tableFilter: Record<string, any> = {};\n          tableFilter[CouchDBKeys.TABLE] = {};\n          tableFilter[CouchDBKeys.TABLE][CouchDBOperator.EQUAL] = tableName;\n          indexes[name].index.partial_filter_selector = tableFilter;\n        }\n      }\n\n      generate();\n      if (directions)\n        (directions as unknown as OrderDirection[]).forEach((d) => generate(d));\n    });\n  });\n  return Object.values(indexes);\n}\n","/******************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise, SuppressedError, Symbol, Iterator */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    if (typeof b !== \"function\" && b !== null)\r\n        throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {\r\n    function accept(f) { if (f !== void 0 && typeof f !== \"function\") throw new TypeError(\"Function expected\"); return f; }\r\n    var kind = contextIn.kind, key = kind === \"getter\" ? \"get\" : kind === \"setter\" ? \"set\" : \"value\";\r\n    var target = !descriptorIn && ctor ? contextIn[\"static\"] ? ctor : ctor.prototype : null;\r\n    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});\r\n    var _, done = false;\r\n    for (var i = decorators.length - 1; i >= 0; i--) {\r\n        var context = {};\r\n        for (var p in contextIn) context[p] = p === \"access\" ? {} : contextIn[p];\r\n        for (var p in contextIn.access) context.access[p] = contextIn.access[p];\r\n        context.addInitializer = function (f) { if (done) throw new TypeError(\"Cannot add initializers after decoration has completed\"); extraInitializers.push(accept(f || null)); };\r\n        var result = (0, decorators[i])(kind === \"accessor\" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);\r\n        if (kind === \"accessor\") {\r\n            if (result === void 0) continue;\r\n            if (result === null || typeof result !== \"object\") throw new TypeError(\"Object expected\");\r\n            if (_ = accept(result.get)) descriptor.get = _;\r\n            if (_ = accept(result.set)) descriptor.set = _;\r\n            if (_ = accept(result.init)) initializers.unshift(_);\r\n        }\r\n        else if (_ = accept(result)) {\r\n            if (kind === \"field\") initializers.unshift(_);\r\n            else descriptor[key] = _;\r\n        }\r\n    }\r\n    if (target) Object.defineProperty(target, contextIn.name, descriptor);\r\n    done = true;\r\n};\r\n\r\nexport function __runInitializers(thisArg, initializers, value) {\r\n    var useValue = arguments.length > 2;\r\n    for (var i = 0; i < initializers.length; i++) {\r\n        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);\r\n    }\r\n    return useValue ? value : void 0;\r\n};\r\n\r\nexport function __propKey(x) {\r\n    return typeof x === \"symbol\" ? x : \"\".concat(x);\r\n};\r\n\r\nexport function __setFunctionName(f, name, prefix) {\r\n    if (typeof name === \"symbol\") name = name.description ? \"[\".concat(name.description, \"]\") : \"\";\r\n    return Object.defineProperty(f, \"name\", { configurable: true, value: prefix ? \"\".concat(prefix, \" \", name) : name });\r\n};\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    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);\r\n    return g.next = verb(0), g[\"throw\"] = verb(1), g[\"return\"] = verb(2), typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (g && (g = 0, op[0] && (_ = 0)), _) try {\r\n            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;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    var desc = Object.getOwnPropertyDescriptor(m, k);\r\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\r\n        desc = { enumerable: true, get: function() { return m[k]; } };\r\n    }\r\n    Object.defineProperty(o, k2, desc);\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n}\r\n\r\nexport function __spreadArray(to, from, pack) {\r\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\r\n        if (ar || !(i in from)) {\r\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\r\n            ar[i] = from[i];\r\n        }\r\n    }\r\n    return to.concat(ar || Array.prototype.slice.call(from));\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = Object.create((typeof AsyncIterator === \"function\" ? AsyncIterator : Object).prototype), verb(\"next\"), verb(\"throw\"), verb(\"return\", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }\r\n    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n    o[\"default\"] = v;\r\n};\r\n\r\nvar ownKeys = function(o) {\r\n    ownKeys = Object.getOwnPropertyNames || function (o) {\r\n        var ar = [];\r\n        for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;\r\n        return ar;\r\n    };\r\n    return ownKeys(o);\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== \"default\") __createBinding(result, mod, k[i]);\r\n    __setModuleDefault(result, mod);\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\r\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\r\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\r\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\r\n}\r\n\r\nexport function __classPrivateFieldIn(state, receiver) {\r\n    if (receiver === null || (typeof receiver !== \"object\" && typeof receiver !== \"function\")) throw new TypeError(\"Cannot use 'in' operator on non-object\");\r\n    return typeof state === \"function\" ? receiver === state : state.has(receiver);\r\n}\r\n\r\nexport function __addDisposableResource(env, value, async) {\r\n    if (value !== null && value !== void 0) {\r\n        if (typeof value !== \"object\" && typeof value !== \"function\") throw new TypeError(\"Object expected.\");\r\n        var dispose, inner;\r\n        if (async) {\r\n            if (!Symbol.asyncDispose) throw new TypeError(\"Symbol.asyncDispose is not defined.\");\r\n            dispose = value[Symbol.asyncDispose];\r\n        }\r\n        if (dispose === void 0) {\r\n            if (!Symbol.dispose) throw new TypeError(\"Symbol.dispose is not defined.\");\r\n            dispose = value[Symbol.dispose];\r\n            if (async) inner = dispose;\r\n        }\r\n        if (typeof dispose !== \"function\") throw new TypeError(\"Object not disposable.\");\r\n        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };\r\n        env.stack.push({ value: value, dispose: dispose, async: async });\r\n    }\r\n    else if (async) {\r\n        env.stack.push({ async: true });\r\n    }\r\n    return value;\r\n\r\n}\r\n\r\nvar _SuppressedError = typeof SuppressedError === \"function\" ? SuppressedError : function (error, suppressed, message) {\r\n    var e = new Error(message);\r\n    return e.name = \"SuppressedError\", e.error = error, e.suppressed = suppressed, e;\r\n};\r\n\r\nexport function __disposeResources(env) {\r\n    function fail(e) {\r\n        env.error = env.hasError ? new _SuppressedError(e, env.error, \"An error was suppressed during disposal.\") : e;\r\n        env.hasError = true;\r\n    }\r\n    var r, s = 0;\r\n    function next() {\r\n        while (r = env.stack.pop()) {\r\n            try {\r\n                if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);\r\n                if (r.dispose) {\r\n                    var result = r.dispose.call(r.value);\r\n                    if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });\r\n                }\r\n                else s |= 1;\r\n            }\r\n            catch (e) {\r\n                fail(e);\r\n            }\r\n        }\r\n        if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();\r\n        if (env.hasError) throw env.error;\r\n    }\r\n    return next();\r\n}\r\n\r\nexport function __rewriteRelativeImportExtension(path, preserveJsx) {\r\n    if (typeof path === \"string\" && /^\\.\\.?\\//.test(path)) {\r\n        return path.replace(/\\.(tsx)$|((?:\\.d)?)((?:\\.[^./]+?)?)\\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {\r\n            return tsx ? preserveJsx ? \".jsx\" : \".js\" : d && (!ext || !cm) ? m : (d + ext + \".\" + cm.toLowerCase() + \"js\");\r\n        });\r\n    }\r\n    return path;\r\n}\r\n\r\nexport default {\r\n    __extends: __extends,\r\n    __assign: __assign,\r\n    __rest: __rest,\r\n    __decorate: __decorate,\r\n    __param: __param,\r\n    __esDecorate: __esDecorate,\r\n    __runInitializers: __runInitializers,\r\n    __propKey: __propKey,\r\n    __setFunctionName: __setFunctionName,\r\n    __metadata: __metadata,\r\n    __awaiter: __awaiter,\r\n    __generator: __generator,\r\n    __createBinding: __createBinding,\r\n    __exportStar: __exportStar,\r\n    __values: __values,\r\n    __read: __read,\r\n    __spread: __spread,\r\n    __spreadArrays: __spreadArrays,\r\n    __spreadArray: __spreadArray,\r\n    __await: __await,\r\n    __asyncGenerator: __asyncGenerator,\r\n    __asyncDelegator: __asyncDelegator,\r\n    __asyncValues: __asyncValues,\r\n    __makeTemplateObject: __makeTemplateObject,\r\n    __importStar: __importStar,\r\n    __importDefault: __importDefault,\r\n    __classPrivateFieldGet: __classPrivateFieldGet,\r\n    __classPrivateFieldSet: __classPrivateFieldSet,\r\n    __classPrivateFieldIn: __classPrivateFieldIn,\r\n    __addDisposableResource: __addDisposableResource,\r\n    __disposeResources: __disposeResources,\r\n    __rewriteRelativeImportExtension: __rewriteRelativeImportExtension,\r\n};\r\n","import type { ModelArg } from \"@decaf-ts/decorator-validation\";\nimport { model, required } from \"@decaf-ts/decorator-validation\";\nimport { BaseModel, pk, index, table } from \"@decaf-ts/core\";\nimport { CouchDBKeys } from \"../constants\";\n\n@table(CouchDBKeys.SEQUENCE)\n@model()\nexport class Sequence extends BaseModel {\n  /**\n   * @summary the Primary key for the DBSequence\n   * @prop name\n   *\n   * @see pk\n   */\n  @pk()\n  id!: string;\n  /**\n   * @summary the current value for the DBSequence\n   * @prop current\n   *\n   * @see required\n   * @see index\n   */\n  @required()\n  @index()\n  current!: string | number;\n\n  constructor(seq?: ModelArg<Sequence>) {\n    super(seq);\n  }\n}\n","import { InternalError } from \"@decaf-ts/db-decorators\";\n\nexport function parseSequenceValue(\n  type: \"Number\" | \"BigInt\" | undefined,\n  value: string | number | bigint\n): string | number | bigint {\n  switch (type) {\n    case \"Number\":\n      return typeof value === \"string\"\n        ? parseInt(value)\n        : typeof value === \"number\"\n          ? value\n          : BigInt(value);\n    case \"BigInt\":\n      return BigInt(value);\n    default:\n      throw new InternalError(\"Should never happen\");\n  }\n}\n","import { sf } from \"@decaf-ts/decorator-validation\";\nimport { Sequence as Seq } from \"../model/CouchDBSequence\";\nimport { InternalError, NotFoundError } from \"@decaf-ts/db-decorators\";\nimport { Adapter, Repository, SequenceOptions } from \"@decaf-ts/core\";\nimport { Sequence } from \"@decaf-ts/core\";\nimport { parseSequenceValue } from \"./utils\";\nimport { MangoQuery } from \"../types\";\nimport { CouchDBRepository } from \"../interfaces\";\n\n/**\n * @summary Abstract implementation of a Sequence\n * @description provides the basic functionality for {@link Sequence}s\n *\n * @param {SequenceOptions} options\n *\n * @class CouchDBSequence\n * @implements Sequence\n *\n * @category Sequences\n */\nexport class CouchDBSequence extends Sequence {\n  protected repo: CouchDBRepository<Seq, any>;\n\n  constructor(options: SequenceOptions, adapter: Adapter<any, MangoQuery>) {\n    super(options);\n    this.repo = Repository.forModel(Seq, adapter.flavour);\n  }\n\n  /**\n   * @summary Retrieves the current value for the sequence\n   * @protected\n   */\n  async current(): Promise<string | number | bigint> {\n    const { name, startWith } = this.options;\n    try {\n      const sequence: Seq = await this.repo.read(name as string);\n      return this.parse(sequence.current as string | number);\n    } catch (e: any) {\n      if (e instanceof NotFoundError) {\n        if (typeof startWith === \"undefined\")\n          throw new InternalError(\n            \"Starting value is not defined for a non existing sequence\"\n          );\n        try {\n          return this.parse(startWith);\n        } catch (e: any) {\n          throw new InternalError(\n            sf(\n              \"Failed to parse initial value for sequence {0}: {1}\",\n              startWith.toString(),\n              e\n            )\n          );\n        }\n      }\n      throw new InternalError(\n        sf(\n          \"Failed to retrieve current value for sequence {0}: {1}\",\n          name as string,\n          e\n        )\n      );\n    }\n  }\n\n  /**\n   * @summary Parses the {@link Sequence} value\n   *\n   * @protected\n   * @param value\n   */\n  private parse(value: string | number | bigint): string | number | bigint {\n    return parseSequenceValue(this.options.type, value);\n  }\n\n  /**\n   * @summary increments the sequence\n   * @description Sequence specific implementation\n   *\n   * @param {string | number | bigint} current\n   * @param count\n   * @protected\n   */\n  private async increment(\n    current: string | number | bigint,\n    count?: number\n  ): Promise<string | number | bigint> {\n    const { type, incrementBy, name } = this.options;\n    let next: string | number | bigint;\n    const toIncrementBy = count || incrementBy;\n    if (toIncrementBy % incrementBy !== 0)\n      throw new InternalError(\n        `Value to increment does not consider the incrementBy setting: ${incrementBy}`\n      );\n    switch (type) {\n      case \"Number\":\n        next = (this.parse(current) as number) + toIncrementBy;\n        break;\n      case \"BigInt\":\n        next = (this.parse(current) as bigint) + BigInt(toIncrementBy);\n        break;\n      default:\n        throw new InternalError(\"Should never happen\");\n    }\n    let seq: Seq;\n    try {\n      seq = await this.repo.update(new Seq({ id: name, current: next }));\n    } catch (e: any) {\n      if (!(e instanceof NotFoundError)) throw e;\n      seq = await this.repo.create(new Seq({ id: name, current: next }));\n    }\n\n    return seq.current as string | number | bigint;\n  }\n\n  /**\n   * @summary Generates the next value in th sequence\n   * @description calls {@link Sequence#parse} on the current value\n   * followed by {@link Sequence#increment}\n   *\n   */\n  async next(): Promise<number | string | bigint> {\n    const current = await this.current();\n    return this.increment(current);\n  }\n\n  async range(count: number): Promise<(number | string | bigint)[]> {\n    const current = (await this.current()) as number;\n    const incrementBy = this.parse(this.options.incrementBy) as number;\n    const next: string | number | bigint = await this.increment(\n      current,\n      (this.parse(count) as number) * incrementBy\n    );\n    const range: (number | string | bigint)[] = [];\n    for (let i: number = 1; i <= count; i++) {\n      range.push(current + incrementBy * (this.parse(i) as number));\n    }\n    if (range[range.length - 1] !== next)\n      throw new InternalError(\"Miscalculation of range\");\n    return range;\n  }\n}\n","import {\n  Paginator,\n  PagingError,\n  SequenceOptions,\n  Statement,\n} from \"@decaf-ts/core\";\nimport {\n  DefaultSeparator,\n  findPrimaryKey,\n  InternalError,\n} from \"@decaf-ts/db-decorators\";\nimport { parseSequenceValue } from \"../sequences/utils\";\nimport { MangoQuery, MangoResponse } from \"../types\";\n\nexport class CouchDBPaginator<V> extends Paginator<V, MangoQuery> {\n  private bookMark?: string;\n\n  get total(): number {\n    throw new InternalError(`The total pages api is not available for couchdb`);\n  }\n\n  get count(): number {\n    throw new InternalError(\n      `The record count api is not available for couchdb`\n    );\n  }\n\n  constructor(\n    statement: Statement<MangoQuery>,\n    size: number,\n    rawStatement: MangoQuery\n  ) {\n    super(statement, size, rawStatement);\n  }\n\n  protected prepare(rawStatement: MangoQuery): MangoQuery {\n    const query: MangoQuery = Object.assign({}, rawStatement);\n    if (query.limit) this.limit = query.limit;\n\n    query.limit = this.size;\n\n    return query;\n  }\n\n  async page(page: number = 1, ...args: any[]): Promise<V[]> {\n    const statement = Object.assign({}, this.statement);\n    const target = this.stat.getTarget();\n    // if (!this._recordCount || !this._totalPages) {\n    //   // this._recordCount = await this.adapter\n    //   //   .Query()\n    //   //   .count()\n    //   //   .from(target)\n    //   //   .execute<number>();\n    // }\n\n    if (page !== 1) {\n      if (!this.bookMark)\n        throw new PagingError(\"No bookmark. Did you start in the first page?\");\n      statement[\"bookmark\"] = this.bookMark;\n    }\n    const rawResult: MangoResponse<any> = await this.adapter.raw(\n      statement,\n      false,\n      ...args\n    );\n\n    const { docs, bookmark, warning } = rawResult;\n    if (warning) console.warn(warning);\n    const results =\n      statement.fields && statement.fields.length\n        ? docs // has fields means its not full model\n        : docs.map((d: any) => {\n            //no fields means we need to revert to saving process\n            if (!target) throw new PagingError(\"No statement target defined\");\n            const pkDef = findPrimaryKey(new target()) as {\n              id: string;\n              props: SequenceOptions;\n            };\n            const pk = pkDef.id;\n            const originalId = d._id.split(DefaultSeparator);\n            originalId.splice(0, 1); // remove the table name\n            return this.adapter.revert(\n              d,\n              target,\n              pk,\n              parseSequenceValue(\n                pkDef.props.type,\n                originalId.join(DefaultSeparator)\n              )\n            );\n          });\n    this.bookMark = bookmark;\n    this._currentPage = page;\n    return results;\n  }\n}\n","import { Adapter, Statement } from \"@decaf-ts/core\";\nimport { findPrimaryKey, InternalError } from \"@decaf-ts/db-decorators\";\nimport { Constructor } from \"@decaf-ts/decorator-validation\";\nimport { CouchDBKeys } from \"../constants\";\nimport { parseSequenceValue } from \"../sequences/utils\";\nimport { Paginator } from \"@decaf-ts/core\";\nimport { CouchDBPaginator } from \"./Paginator\";\nimport { MangoQuery } from \"../types\";\n\nexport class CouchDBStatement<Y> extends Statement<MangoQuery> {\n  constructor(adapter: Adapter<Y, MangoQuery>) {\n    super(adapter);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  async execute<Y>(): Promise<Y> {\n    try {\n      const query: MangoQuery = this.build();\n      if (!query.limit) query.limit = Number.MAX_SAFE_INTEGER;\n      return this.raw(query);\n    } catch (e: any) {\n      throw new InternalError(e);\n    }\n  }\n\n  async paginate<R>(size: number): Promise<Paginator<R, MangoQuery>> {\n    try {\n      const query: MangoQuery = this.build();\n      return new CouchDBPaginator(this, size, query);\n    } catch (e: any) {\n      throw new InternalError(e);\n    }\n  }\n\n  private processRecord(\n    r: any,\n    pkAttr: string,\n    sequenceType: \"Number\" | \"BigInt\" | undefined\n  ) {\n    if (!r[CouchDBKeys.ID])\n      throw new InternalError(\n        `No CouchDB Id definition found. Should not be possible`\n      );\n    const [, ...keyArgs] = r[CouchDBKeys.ID].split(\"_\");\n\n    const id = keyArgs.join(\"_\");\n    return this.adapter.revert(\n      r,\n      this.target as Constructor<any>,\n      pkAttr,\n      parseSequenceValue(sequenceType, id)\n    ) as any;\n  }\n\n  async raw<R>(rawInput: MangoQuery, ...args: any[]): Promise<R> {\n    const results = await this.adapter.raw<R>(rawInput, true, ...args);\n    if (!this.fullRecord) return results;\n    if (!this.target)\n      throw new InternalError(\n        \"No target defined in statement. should never happen\"\n      );\n\n    const pkDef = findPrimaryKey(new this.target() as any);\n    const pkAttr = pkDef.id;\n    const type = pkDef.props.type;\n    if (Array.isArray(results))\n      return results.map((r) => this.processRecord(r, pkAttr, type)) as R;\n    return this.processRecord(results, pkAttr, type) as R;\n  }\n}\n","import { FromClause } from \"@decaf-ts/core\";\nimport { ModelArg, Model, Constructor } from \"@decaf-ts/decorator-validation\";\nimport { CouchDBKeys } from \"../constants\";\nimport { Repository } from \"@decaf-ts/core\";\nimport { MangoQuery } from \"../types\";\n\n// noinspection JSAnnotator\nexport class CouchDBFromClause<M extends Model> extends FromClause<\n  MangoQuery,\n  M\n> {\n  constructor(clause: ModelArg<FromClause<MangoQuery, M>>) {\n    super(clause);\n  }\n\n  build(previous: MangoQuery): MangoQuery {\n    const selectors: any = {};\n    selectors[CouchDBKeys.TABLE] = {};\n    selectors[CouchDBKeys.TABLE] =\n      typeof this.selector === \"string\"\n        ? this.selector\n        : Repository.table(this.selector as Constructor<M>);\n    previous.selector = selectors;\n    return previous;\n  }\n}\n","import { InsertClause } from \"@decaf-ts/core\";\nimport { ModelArg, Model } from \"@decaf-ts/decorator-validation\";\nimport { InternalError } from \"@decaf-ts/db-decorators\";\nimport { MangoQuery } from \"../types\";\n\n// noinspection JSAnnotator\nexport class CouchDBInsertClause<M extends Model> extends InsertClause<\n  MangoQuery,\n  M\n> {\n  constructor(clause: ModelArg<InsertClause<MangoQuery, M>>) {\n    super(clause);\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  build(query: MangoQuery): MangoQuery {\n    throw new InternalError(\"Not supported\");\n  }\n}\n","import { Condition, WhereClause } from \"@decaf-ts/core\";\nimport { ModelArg } from \"@decaf-ts/decorator-validation\";\nimport { CouchDBGroupOperator } from \"./constants\";\nimport { sf } from \"@decaf-ts/decorator-validation\";\nimport { CouchDBKeys } from \"../constants\";\nimport { MangoOperator, MangoQuery, MangoSelector } from \"../types\";\n\nexport class CouchDBWhereClause extends WhereClause<MangoQuery> {\n  constructor(clause: ModelArg<WhereClause<MangoQuery>>) {\n    super(clause);\n  }\n\n  build(query: MangoQuery): MangoQuery {\n    const condition: MangoSelector = this.adapter.parseCondition(\n      Condition.and(\n        this.condition as Condition,\n        Condition.attribute(CouchDBKeys.TABLE).eq(\n          query.selector[CouchDBKeys.TABLE]\n        )\n      )\n    ).selector;\n\n    const selectorKeys = Object.keys(condition) as MangoOperator[];\n    if (\n      selectorKeys.length === 1 &&\n      Object.values(CouchDBGroupOperator).indexOf(selectorKeys[0]) !== -1\n    )\n      switch (selectorKeys[0]) {\n        case CouchDBGroupOperator.AND:\n          condition[CouchDBGroupOperator.AND] = [\n            ...Object.values(\n              condition[CouchDBGroupOperator.AND] as MangoSelector\n            ).reduce((accum: MangoSelector[], val: any) => {\n              const keys = Object.keys(val);\n              if (keys.length !== 1)\n                throw new Error(\n                  \"Too many keys in query selector. should be one\"\n                );\n              const k = keys[0];\n              if (k === CouchDBGroupOperator.AND)\n                accum.push(...(val[k] as any[]));\n              else accum.push(val);\n              return accum;\n            }, []),\n          ];\n          query.selector = condition;\n          break;\n        case CouchDBGroupOperator.OR: {\n          const s: Record<any, any> = {};\n          s[CouchDBGroupOperator.AND] = [\n            condition,\n            ...Object.entries(query.selector).map(([key, val]) => {\n              const result: Record<any, any> = {};\n              result[key] = val;\n              return result;\n            }),\n          ];\n          query.selector = s;\n          break;\n        }\n        default:\n          throw new Error(\"This should be impossible\");\n      }\n    else {\n      Object.entries(condition).forEach(([key, val]) => {\n        if (query.selector[key])\n          console.warn(\n            sf(\n              \"A {0} query param is about to be overridden: {1} by {2}\",\n              key,\n              query.selector[key] as unknown as string,\n              val as unknown as string\n            )\n          );\n        query.selector[key] = val;\n      });\n    }\n\n    return query;\n  }\n}\n","import { Const, SelectClause } from \"@decaf-ts/core\";\nimport { ModelArg, Model } from \"@decaf-ts/decorator-validation\";\nimport { MangoQuery } from \"../types\";\n\nexport class CouchDBSelectClause<M extends Model> extends SelectClause<\n  MangoQuery,\n  M\n> {\n  constructor(clause: ModelArg<SelectClause<MangoQuery, M>>) {\n    super(clause);\n  }\n\n  build(query: MangoQuery): MangoQuery {\n    if (!this.selector || this.selector === Const.FULL_RECORD) return query;\n    query.fields =\n      typeof this.selector === \"string\"\n        ? [this.selector as string]\n        : (this.selector as string[]);\n    return query;\n  }\n}\n","import { ValuesClause } from \"@decaf-ts/core\";\nimport { ModelArg, Model } from \"@decaf-ts/decorator-validation\";\nimport { InternalError } from \"@decaf-ts/db-decorators\";\nimport { MangoQuery } from \"../types\";\n\nexport class CouchDBValuesClause<M extends Model> extends ValuesClause<\n  MangoQuery,\n  M\n> {\n  constructor(clause: ModelArg<ValuesClause<MangoQuery, M>>) {\n    super(clause);\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  build(previous: MangoQuery): MangoQuery {\n    throw new InternalError(\"Not implemented\");\n  }\n}\n","import {\n  ClauseFactory,\n  Condition,\n  FromClause,\n  FromSelector,\n  GroupBySelector,\n  LimitSelector,\n  OffsetSelector,\n  OrderBySelector,\n  QueryError,\n  SelectSelector,\n  Statement,\n} from \"@decaf-ts/core\";\nimport { LimitClause } from \"@decaf-ts/core\";\nimport { SelectClause } from \"@decaf-ts/core\";\nimport { WhereClause } from \"@decaf-ts/core\";\nimport { OffsetClause } from \"@decaf-ts/core\";\nimport { OrderByClause } from \"@decaf-ts/core\";\nimport { GroupByClause } from \"@decaf-ts/core\";\nimport { ValuesClause } from \"@decaf-ts/core\";\nimport { InsertClause } from \"@decaf-ts/core\";\nimport { CouchDBFromClause } from \"./FromClause\";\nimport { ModelArg, Model } from \"@decaf-ts/decorator-validation\";\nimport { InternalError } from \"@decaf-ts/db-decorators\";\nimport { CouchDBInsertClause } from \"./InsertClause\";\nimport { CouchDBStatement } from \"./Statement\";\nimport { CouchDBWhereClause } from \"./WhereClause\";\nimport { CouchDBSelectClause } from \"./SelectClause\";\nimport { CouchDBValuesClause } from \"./ValuesClause\";\nimport { CouchDBOperator } from \"./constants\";\nimport { CouchDBAdapter } from \"../adapter\";\nimport { MangoQuery, MangoSelector } from \"../types\";\n\nexport class Factory<S> extends ClauseFactory<S, MangoQuery> {\n  constructor(adapter: CouchDBAdapter<S>) {\n    super(adapter);\n  }\n\n  from<M extends Model>(\n    statement: Statement<MangoQuery>,\n    selector: FromSelector<M>\n  ): FromClause<MangoQuery, M> {\n    return new CouchDBFromClause({ statement: statement, selector: selector });\n  }\n\n  groupBy(\n    statement: Statement<MangoQuery>,\n    selector: GroupBySelector\n  ): GroupByClause<MangoQuery> {\n    return new (class extends GroupByClause<MangoQuery> {\n      constructor(clause: ModelArg<GroupByClause<MangoQuery>>) {\n        super(clause);\n      }\n\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n      build(query: MangoQuery): MangoQuery {\n        throw new InternalError(\"Not implemented\");\n      }\n    })({\n      statement: statement,\n      selector: selector,\n    });\n  }\n\n  insert<M extends Model>(): InsertClause<MangoQuery, M> {\n    return new CouchDBInsertClause({\n      statement: new CouchDBStatement(this.adapter),\n    });\n  }\n\n  limit(\n    statement: Statement<MangoQuery>,\n    selector: LimitSelector\n  ): LimitClause<MangoQuery> {\n    return new (class extends LimitClause<MangoQuery> {\n      constructor(clause: ModelArg<LimitClause<MangoQuery>>) {\n        super(clause);\n      }\n\n      build(query: MangoQuery): MangoQuery {\n        query.limit = this.selector as number;\n        return query;\n      }\n    })({\n      statement: statement,\n      selector: selector,\n    });\n  }\n\n  offset(\n    statement: Statement<MangoQuery>,\n    selector: OffsetSelector\n  ): OffsetClause<MangoQuery> {\n    return new (class extends OffsetClause<MangoQuery> {\n      constructor(clause: ModelArg<OffsetClause<MangoQuery>>) {\n        super(clause);\n      }\n\n      build(query: MangoQuery): MangoQuery {\n        const skip: number = parseInt(this.selector as unknown as string);\n        if (isNaN(skip)) throw new QueryError(\"Failed to parse offset\");\n        query.skip = skip;\n        return query;\n      }\n    })({\n      statement: statement,\n      selector: selector,\n    });\n  }\n\n  orderBy(\n    statement: Statement<MangoQuery>,\n    selector: OrderBySelector[]\n  ): OrderByClause<MangoQuery> {\n    return new (class extends OrderByClause<MangoQuery> {\n      constructor(clause: ModelArg<OrderByClause<MangoQuery>>) {\n        super(clause);\n      }\n\n      build(query: MangoQuery): MangoQuery {\n        query.sort = query.sort || [];\n        query.selector = query.selector || ({} as MangoSelector);\n        this.selector!.forEach((s) => {\n          const [selector, value] = s;\n          const rec: any = {};\n          rec[selector] = value;\n          (query.sort as any[]).push(rec as any);\n          if (!query.selector[selector]) {\n            query.selector[selector] = {} as MangoSelector;\n            (query.selector[selector] as MangoSelector)[\n              CouchDBOperator.BIGGER\n            ] = null;\n          }\n          // query.fields = query.fields || [];\n          // query.fields = [...new Set([...query.fields, selector]).keys()]\n        });\n        return query;\n      }\n    })({\n      statement: statement,\n      selector: selector,\n    });\n  }\n\n  select<M extends Model>(\n    selector: SelectSelector | undefined\n  ): SelectClause<MangoQuery, M> {\n    return new CouchDBSelectClause({\n      statement: new CouchDBStatement(this.adapter),\n      selector: selector,\n    });\n  }\n\n  values<M extends Model>(\n    statement: Statement<MangoQuery>,\n    values: M[]\n  ): ValuesClause<MangoQuery, M> {\n    return new CouchDBValuesClause<M>({\n      statement: statement,\n      values: values,\n    });\n  }\n\n  where(\n    statement: Statement<MangoQuery>,\n    condition: Condition\n  ): WhereClause<MangoQuery> {\n    return new CouchDBWhereClause({\n      statement: statement,\n      condition: condition,\n    });\n  }\n}\n","import { GroupOperator, Operator } from \"@decaf-ts/core\";\nimport { CouchDBGroupOperator, CouchDBOperator } from \"./constants\";\nimport { QueryError } from \"@decaf-ts/core\";\nimport { MangoOperator } from \"../types\";\n\nexport function translateOperators(\n  operator: GroupOperator | Operator\n): MangoOperator {\n  for (const operators of [CouchDBOperator, CouchDBGroupOperator]) {\n    const el = Object.keys(operators).find((k) => k === operator);\n    if (el) return operators[el];\n  }\n  throw new QueryError(\n    `Could not find adapter translation for operator ${operator}`\n  );\n}\n","import { BaseError } from \"@decaf-ts/db-decorators\";\n\nexport class IndexError extends BaseError {\n  constructor(msg: string | Error) {\n    super(IndexError.name, msg);\n  }\n}\n","import {\n  Adapter,\n  Sequence,\n  SequenceOptions,\n  PersistenceKeys,\n  Operator,\n  GroupOperator,\n  Statement,\n  Query,\n  ClauseFactory,\n  Condition,\n  ConnectionError,\n  Repository,\n  User,\n} from \"@decaf-ts/core\";\nimport { CouchDBKeys, reservedAttributes } from \"./constants\";\nimport {\n  BaseError,\n  ConflictError,\n  InternalError,\n  NotFoundError,\n  prefixMethod,\n} from \"@decaf-ts/db-decorators\";\nimport \"reflect-metadata\";\nimport { CouchDBStatement } from \"./query/Statement\";\nimport { Factory } from \"./query\";\nimport { translateOperators } from \"./query/translate\";\nimport { CouchDBSequence } from \"./sequences/Sequence\";\nimport { Constructor, Model } from \"@decaf-ts/decorator-validation\";\nimport { IndexError } from \"./errors\";\nimport { MangoOperator, MangoQuery, MangoSelector } from \"./types\";\n\nexport abstract class CouchDBAdapter<S> extends Adapter<S, MangoQuery> {\n  protected factory?: Factory<S>;\n\n  protected constructor(scope: S, flavour: string) {\n    super(scope, flavour);\n    [this.create, this.createAll, this.update, this.updateAll].forEach((m) => {\n      const name = m.name;\n      prefixMethod(this, m, (this as any)[name + \"Prefix\"]);\n    });\n  }\n\n  get Clauses(): ClauseFactory<S, MangoQuery> {\n    if (!this.factory) this.factory = new Factory(this);\n    return this.factory;\n  }\n\n  Query<M extends Model>(): Query<MangoQuery, M> {\n    return super.Query();\n  }\n\n  get Statement(): Statement<MangoQuery> {\n    return new CouchDBStatement(this);\n  }\n\n  parseCondition(condition: Condition): MangoQuery {\n    function merge(\n      op: MangoOperator,\n      obj1: MangoSelector,\n      obj2: MangoSelector\n    ): MangoQuery {\n      const result: MangoQuery = { selector: {} as MangoSelector };\n      result.selector[op] = [obj1, obj2];\n      return result;\n    }\n\n    const { attr1, operator, comparison } = condition as unknown as {\n      attr1: string | Condition;\n      operator: Operator | GroupOperator;\n      comparison: any;\n    };\n\n    let op: MangoSelector = {} as MangoSelector;\n    if (\n      [GroupOperator.AND, GroupOperator.OR, Operator.NOT].indexOf(\n        operator as GroupOperator\n      ) === -1\n    ) {\n      op[attr1 as string] = {} as MangoSelector;\n      (op[attr1 as string] as MangoSelector)[translateOperators(operator)] =\n        comparison;\n    } else if (operator === Operator.NOT) {\n      op = this.parseCondition(attr1 as Condition).selector as MangoSelector;\n      op[translateOperators(Operator.NOT)] = {} as MangoSelector;\n      (op[translateOperators(Operator.NOT)] as MangoSelector)[\n        (attr1 as unknown as { attr1: string }).attr1\n      ] = comparison;\n    } else {\n      const op1: any = this.parseCondition(attr1 as Condition).selector;\n      const op2: any = this.parseCondition(comparison as Condition).selector;\n      op = merge(translateOperators(operator), op1, op2).selector;\n    }\n\n    return { selector: op };\n  }\n\n  async Sequence(options: SequenceOptions): Promise<Sequence> {\n    return new CouchDBSequence(options, this);\n  }\n\n  async initialize(): Promise<void> {\n    const managedModels = Adapter.models(this.flavour);\n    return this.index(...managedModels);\n  }\n\n  protected abstract index<M extends Model>(\n    ...models: Constructor<M>[]\n  ): Promise<void>;\n\n  protected abstract user(): Promise<User>;\n\n  abstract raw<V>(rawInput: MangoQuery, process: boolean): Promise<V>;\n\n  protected assignMetadata(\n    model: Record<string, any>,\n    rev: string\n  ): Record<string, any> {\n    Object.defineProperty(model, PersistenceKeys.METADATA, {\n      enumerable: false,\n      configurable: false,\n      writable: false,\n      value: rev,\n    });\n    return model;\n  }\n\n  protected assignMultipleMetadata(\n    models: Record<string, any>[],\n    revs: string[]\n  ): Record<string, any>[] {\n    models.forEach((m, i) => {\n      Repository.setMetadata(m as any, revs[i]);\n      return m;\n    });\n    return models;\n  }\n\n  protected createPrefix(\n    tableName: string,\n    id: string | number,\n    model: Record<string, any>\n  ) {\n    const record: Record<string, any> = {};\n    record[CouchDBKeys.TABLE] = tableName;\n    record[CouchDBKeys.ID] = this.generateId(tableName, id);\n    Object.assign(record, model);\n    return [tableName, id, record];\n  }\n\n  abstract create(\n    tableName: string,\n    id: string | number,\n    model: Record<string, any>\n  ): Promise<Record<string, any>>;\n\n  protected createAllPrefix(\n    tableName: string,\n    ids: string[] | number[],\n    models: Record<string, any>[]\n  ) {\n    if (ids.length !== models.length)\n      throw new InternalError(\"Ids and models must have the same length\");\n\n    const records = ids.map((id, count) => {\n      const record: Record<string, any> = {};\n      record[CouchDBKeys.TABLE] = tableName;\n      record[CouchDBKeys.ID] = this.generateId(tableName, id);\n      Object.assign(record, models[count]);\n      return record;\n    });\n    return [tableName, ids, records];\n  }\n\n  abstract createAll(\n    tableName: string,\n    ids: string[] | number[],\n    models: Record<string, any>[]\n  ): Promise<Record<string, any>[]>;\n\n  abstract read(\n    tableName: string,\n    id: string | number\n  ): Promise<Record<string, any>>;\n\n  abstract readAll(\n    tableName: string,\n    ids: (string | number | bigint)[]\n  ): Promise<Record<string, any>[]>;\n\n  updatePrefix(\n    tableName: string,\n    id: string | number,\n    model: Record<string, any>\n  ) {\n    const record: Record<string, any> = {};\n    record[CouchDBKeys.TABLE] = tableName;\n    record[CouchDBKeys.ID] = this.generateId(tableName, id);\n    const rev = model[PersistenceKeys.METADATA];\n    if (!rev)\n      throw new InternalError(\n        `No revision number found for record with id ${id}`\n      );\n    Object.assign(record, model);\n    record[CouchDBKeys.REV] = rev;\n    return [tableName, id, record];\n  }\n\n  abstract update(\n    tableName: string,\n    id: string | number,\n    model: Record<string, any>\n  ): Promise<Record<string, any>>;\n\n  protected updateAllPrefix(\n    tableName: string,\n    ids: string[] | number[],\n    models: Record<string, any>[]\n  ) {\n    if (ids.length !== models.length)\n      throw new InternalError(\"Ids and models must have the same length\");\n\n    const records = ids.map((id, count) => {\n      const record: Record<string, any> = {};\n      record[CouchDBKeys.TABLE] = tableName;\n      record[CouchDBKeys.ID] = this.generateId(tableName, id);\n      const rev = models[count][PersistenceKeys.METADATA];\n      if (!rev)\n        throw new InternalError(\n          `No revision number found for record with id ${id}`\n        );\n      Object.assign(record, models[count]);\n      record[CouchDBKeys.REV] = rev;\n      return record;\n    });\n    return [tableName, ids, records];\n  }\n\n  abstract updateAll(\n    tableName: string,\n    ids: string[] | number[],\n    models: Record<string, any>[]\n  ): Promise<Record<string, any>[]>;\n\n  abstract delete(\n    tableName: string,\n    id: string | number\n  ): Promise<Record<string, any>>;\n\n  abstract deleteAll(\n    tableName: string,\n    ids: (string | number | bigint)[]\n  ): Promise<Record<string, any>[]>;\n\n  protected generateId(tableName: string, id: string | number) {\n    return [tableName, id].join(CouchDBKeys.SEPARATOR);\n  }\n\n  protected parseError(err: Error | string, reason?: string): BaseError {\n    return CouchDBAdapter.parseError(err, reason);\n  }\n\n  protected isReserved(attr: string): boolean {\n    return !!attr.match(reservedAttributes);\n  }\n\n  protected static parseError(err: Error | string, reason?: string): BaseError {\n    if (err instanceof BaseError) return err as any;\n    let code: string = \"\";\n    if (typeof err === \"string\") {\n      code = err;\n      if (code.match(/already exist|update conflict/g))\n        return new ConflictError(code);\n      if (code.match(/missing|deleted/g)) return new NotFoundError(code);\n    } else if ((err as any).code) {\n      code = (err as any).code;\n      reason = reason || err.message;\n    } else if ((err as any).statusCode) {\n      code = (err as any).statusCode;\n      reason = reason || err.message;\n    } else {\n      code = err.message;\n    }\n\n    switch (code.toString()) {\n      case \"401\":\n      case \"412\":\n      case \"409\":\n        return new ConflictError(reason as string);\n      case \"404\":\n        return new NotFoundError(reason as string);\n      case \"400\":\n        if (code.toString().match(/No\\sindex\\sexists/g))\n          return new IndexError(err);\n        return new InternalError(err);\n      default:\n        if (code.toString().match(/ECONNREFUSED/g))\n          return new ConnectionError(err);\n        return new InternalError(err);\n    }\n  }\n}\n","import { OrderDirection, PersistenceKeys } from \"@decaf-ts/core\";\nimport { CouchDBKeys } from \"./constants\";\nimport { DefaultSeparator } from \"@decaf-ts/db-decorators\";\nimport { CouchDBOperator } from \"./query/constants\";\nimport { CreateIndexRequest, MangoSelector, SortOrder } from \"./types\";\n\nexport async function reAuth(con: any, user: string, pass: string) {\n  return con.auth(user, pass);\n}\n\nexport function wrapDocumentScope(\n  con: any,\n  dbName: string,\n  user: string,\n  pass: string\n): any {\n  const db = con.use(dbName);\n  [\"insert\", \"get\", \"put\", \"destroy\", \"find\"].forEach((k) => {\n    const original = (db as Record<string, any>)[k];\n    Object.defineProperty(db, k, {\n      enumerable: false,\n      configurable: true,\n      value: async (...args: any[]) => {\n        await reAuth(con, user, pass);\n        return original.call(db, ...args);\n      },\n    });\n  });\n  Object.defineProperty(db, CouchDBKeys.NATIVE, {\n    enumerable: false,\n    configurable: false,\n    writable: false,\n    value: con,\n  });\n  return db;\n}\n\nexport function testReservedAttributes(attr: string) {\n  const regexp = /^_.*$/g;\n  return attr.match(regexp);\n}\n\nexport function generateIndexName(\n  attribute: string,\n  tableName: string,\n  compositions?: string[],\n  order?: OrderDirection,\n  separator = DefaultSeparator\n): string {\n  const attr = [PersistenceKeys.INDEX, tableName, attribute];\n  if (compositions) attr.push(...compositions);\n  if (order) attr.push(order);\n  return attr.join(separator);\n}\n\nexport function generateIndexDoc(\n  attribute: string,\n  tableName: string,\n  compositions?: string[],\n  order?: OrderDirection,\n  separator = DefaultSeparator\n): CreateIndexRequest {\n  const partialFilterSelector: MangoSelector = {};\n  partialFilterSelector[CouchDBKeys.TABLE] = {} as MangoSelector;\n  (partialFilterSelector[CouchDBKeys.TABLE] as MangoSelector)[\n    CouchDBOperator.EQUAL\n  ] = tableName;\n  let fields: SortOrder[];\n  if (order) {\n    const orderProp: SortOrder = {};\n    orderProp[attribute] = order as \"asc\" | \"desc\";\n    const sortedCompositions: SortOrder[] = (compositions || []).map((c) => {\n      const r: SortOrder = {};\n      r[c] = order as \"asc\" | \"desc\";\n      return r;\n    });\n    const sortedTable: SortOrder = {};\n    sortedTable[CouchDBKeys.TABLE] = order as \"asc\" | \"desc\";\n    fields = [orderProp, ...sortedCompositions, sortedTable];\n  } else {\n    fields = [attribute, ...(compositions || []), CouchDBKeys.TABLE];\n  }\n  const name = generateIndexName(\n    attribute,\n    tableName,\n    compositions,\n    order,\n    separator\n  );\n  return {\n    index: {\n      fields: fields,\n      // partial_filter_selector: partialFilterSelector,\n    },\n    ddoc: [name, CouchDBKeys.DDOC].join(separator),\n    name: name,\n  };\n}\n","export * from \"./indexes\";\nexport * from \"./interfaces\";\nexport * from \"./model\";\nexport * from \"./sequences\";\nexport * from \"./adapter\";\nexport * from \"./constants\";\nexport * from \"./errors\";\nexport * from \"./types\";\nexport * from \"./utils\";\n\n/**\n * @summary Module summary\n * @description Module description\n * @module ts-workspace\n */\n\n/**\n * @summary Namespace summary\n * @description Namespace description\n * @namespace Namespace\n * @memberOf module:ts-workspace\n */\n\n/**\n * @summary stores the current package version\n * @description this is how you should document a constant\n * @const VERSION\n * @memberOf module:ts-workspace\n */\nexport const VERSION = \"##VERSION##\";\n"],"names":["generateIndexName","DefaultSeparator","Repository","PersistenceKeys","Sequence","BaseModel","pk","required","index","table","model","InternalError","Seq","NotFoundError","sf","Paginator","PagingError","findPrimaryKey","Statement","FromClause","InsertClause","WhereClause","Condition","SelectClause","Const","ValuesClause","ClauseFactory","GroupByClause","LimitClause","OffsetClause","QueryError","OrderByClause","BaseError","Adapter","prefixMethod","GroupOperator","Operator","ConflictError","ConnectionError"],"mappings":"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","x_google_ignoreList":[3]}