couchbase/dist/analyticsexecutor.js

The official Couchbase Node.js Client Library.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.AnalyticsExecutor = void 0;
/* eslint jsdoc/require-jsdoc: off */
const analyticstypes_1 = require("./analyticstypes");
const bindingutilities_1 = require("./bindingutilities");
const observability_1 = require("./observability");
const observabilityhandler_1 = require("./observabilityhandler");
const observabilitytypes_1 = require("./observabilitytypes");
const streamablepromises_1 = require("./streamablepromises");
const utilities_1 = require("./utilities");
/**
 * @internal
 */
class AnalyticsExecutor {
    /**
     * @internal
     */
    constructor(cluster) {
        this._cluster = cluster;
    }
    /**
     * @internal
     */
    get observabilityInstruments() {
        return this._cluster.observabilityInstruments;
    }
    /**
     * @internal
     */
    static _processAnalyticsResponse(emitter, err, resp, obsReqHandler) {
        if (err) {
            obsReqHandler === null || obsReqHandler === void 0 ? void 0 : obsReqHandler.endWithError(err);
            emitter.emit('error', err);
            emitter.emit('end');
            return;
        }
        resp.rows.forEach((row) => {
            emitter.emit('row', JSON.parse(row));
        });
        {
            const metaData = resp.meta;
            let warnings;
            if (metaData.warnings) {
                warnings = metaData.warnings.map((warningData) => new analyticstypes_1.AnalyticsWarning({
                    code: warningData.code,
                    message: warningData.message,
                }));
            }
            else {
                warnings = [];
            }
            const metricsData = metaData.metrics;
            const metrics = new analyticstypes_1.AnalyticsMetrics({
                elapsedTime: metricsData.elapsed_time,
                executionTime: metricsData.execution_time,
                resultCount: metricsData.result_count,
                resultSize: metricsData.result_size,
                errorCount: metricsData.error_count,
                processedObjects: metricsData.processed_objects,
                warningCount: metricsData.warning_count,
            });
            const meta = new analyticstypes_1.AnalyticsMetaData({
                requestId: metaData.request_id,
                clientContextId: metaData.client_context_id,
                status: (0, bindingutilities_1.analyticsStatusFromCpp)(metaData.status),
                signature: metaData.signature
                    ? JSON.parse(metaData.signature)
                    : undefined,
                warnings: warnings,
                metrics: metrics,
            });
            emitter.emit('meta', meta);
        }
        obsReqHandler === null || obsReqHandler === void 0 ? void 0 : obsReqHandler.end();
        emitter.emit('end');
    }
    /**
     * @internal
     */
    static executePromise(queryPromise, obsReqHandler) {
        const emitter = new streamablepromises_1.StreamableRowPromise((rows, meta) => {
            return new analyticstypes_1.AnalyticsResult({
                rows: rows,
                meta: meta,
            });
        });
        utilities_1.PromiseHelper.wrapAsync(async () => {
            const [err, resp] = await queryPromise;
            AnalyticsExecutor._processAnalyticsResponse(emitter, err, resp, obsReqHandler);
        });
        return emitter;
    }
    /**
     * @internal
     */
    query(query, options) {
        const timeout = options.timeout || this._cluster.analyticsTimeout;
        const obsReqHandler = new observabilityhandler_1.ObservableRequestHandler(observabilitytypes_1.StreamingOp.Analytics, this.observabilityInstruments, options === null || options === void 0 ? void 0 : options.parentSpan);
        obsReqHandler.setRequestHttpAttributes({
            statement: query,
            queryContext: options.queryContext,
            queryOptions: options,
        });
        return AnalyticsExecutor.executePromise((0, observability_1.wrapObservableBindingCall)(this._cluster.conn.analytics.bind(this._cluster.conn), {
            statement: query,
            timeout,
            client_context_id: options.clientContextId,
            readonly: options.readOnly || false,
            priority: options.priority || false,
            scope_qualifier: options.queryContext,
            scan_consistency: (0, bindingutilities_1.analyticsScanConsistencyToCpp)(options.scanConsistency),
            raw: options.raw
                ? Object.fromEntries(Object.entries(options.raw)
                    .filter(([, v]) => v !== undefined)
                    .map(([k, v]) => [k, JSON.stringify(v)]))
                : {},
            positional_parameters: options.parameters && Array.isArray(options.parameters)
                ? options.parameters.map((v) => JSON.stringify(v !== null && v !== void 0 ? v : null))
                : [],
            named_parameters: options.parameters && !Array.isArray(options.parameters)
                ? Object.fromEntries(Object.entries(options.parameters)
                    .filter(([, v]) => v !== undefined)
                    .map(([k, v]) => [k, JSON.stringify(v)]))
                : {},
            body_str: '',
        }, obsReqHandler), obsReqHandler);
    }
}
exports.AnalyticsExecutor = AnalyticsExecutor;