ottoman/lib/handler/find/find.js

Ottoman Couchbase ODM

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.find = void 0;
const __1 = require("../..");
const model_utils_1 = require("../../model/utils/model.utils");
const query_1 = require("../../query");
const cast_strategy_1 = require("../../utils/cast-strategy");
const is_debug_mode_1 = require("../../utils/is-debug-mode");
const extract_select_1 = require("../../utils/query/extract-select");
const type_helpers_1 = require("../../utils/type-helpers");
const constants_1 = require("../../utils/constants");
/**
 * Find documents using filter and options.
 * @ignore
 */
const find = (metadata) => (filter = {}, options = {}) => __awaiter(void 0, void 0, void 0, function* () {
    const { skip, limit, sort, populate, select, noCollection, populateMaxDeep: deep, consistency, lean, ignoreCase, enforceRefCheck, transactionContext, } = options;
    const { ottoman, collectionName, modelKey, scopeName, modelName, ID_KEY, schema } = metadata;
    const { bucketName, cluster, couchbase } = ottoman;
    let fromClause = bucketName;
    let selectDot = bucketName;
    if (collectionName !== '_default') {
        fromClause = `\`${bucketName}\`.\`${scopeName}\`.\`${collectionName}\``;
        selectDot = collectionName;
    }
    // Handling select
    const Model = ottoman.getModel(modelName);
    let fields = Object.keys((0, __1.getModelMetadata)(Model).schema.fields);
    if (!fields.includes(ID_KEY)) {
        fields.push(ID_KEY);
    }
    if (!fields.includes(constants_1.MODEL_KEY)) {
        fields.push(constants_1.MODEL_KEY);
    }
    fields = fields.map((field) => `\`${field}\``);
    if (select || !schema.options.strict) {
        fields = select;
    }
    const projectionFields = (0, extract_select_1.getProjectionFields)(selectDot, fields, {
        noCollection: !schema.options.strict ? noCollection : true,
    }, modelKey);
    // Handling conditions
    const expr_where = Object.assign(Object.assign({}, filter), { [modelKey]: modelName });
    // Building the query
    let query = new query_1.Query({}, fromClause).select(projectionFields.projection).where(expr_where);
    if ((0, type_helpers_1.isNumber)(limit)) {
        query = query.limit(limit);
    }
    if (skip) {
        query = query.offset(skip);
    }
    if (sort) {
        query = query.orderBy(sort);
    }
    const queryOptions = {};
    const _consistency = consistency || ottoman.config.consistency || __1.SearchConsistency.NONE;
    switch (_consistency) {
        case __1.SearchConsistency.GLOBAL:
        case __1.SearchConsistency.LOCAL:
            queryOptions.scanConsistency = couchbase.QueryScanConsistency.RequestPlus;
            break;
        case __1.SearchConsistency.NONE:
            queryOptions.scanConsistency = couchbase.QueryScanConsistency.NotBounded;
            break;
    }
    const direct = (lean && !populate) || select === 'RAW COUNT(*) as count';
    const n1ql = query.build({ ignoreCase });
    if ((0, is_debug_mode_1.isDebugMode)()) {
        console.log(n1ql);
    }
    let result;
    if (transactionContext) {
        result = yield transactionContext.query(n1ql, queryOptions);
    }
    else {
        result = yield cluster.query(n1ql, queryOptions);
    }
    if (direct)
        return result;
    if (populate) {
        const params = {
            deep,
            lean,
            schema,
            ottoman,
            modelName,
            fieldsName: populate,
            enforceRefCheck,
            transactionContext,
        };
        result.rows = yield Promise.all(result.rows.map((pojo) => (0, model_utils_1.getPopulated)(Object.assign(Object.assign({}, params), { pojo }))));
    }
    else {
        const newModelOptions = { strict: false, strategy: cast_strategy_1.CAST_STRATEGY.KEEP };
        result.rows = result.rows.map((row) => new Model(row, newModelOptions).$wasNew());
    }
    return result;
});
exports.find = find;
//# sourceMappingURL=find.js.map