couchbase 4.6.0 → 4.7.0-dev.1

package/dist/observabilityutilities.d.ts

@@ -0,0 +1,60 @@
+import { AnalyticsQueryOptions } from './analyticstypes';
+import { CppDocumentId, CppDurabilityLevel, HiResTime } from './binding';
+import { AttributeValue, HttpOpType, KeyValueOp, TimeInput } from './observabilitytypes';
+import { QueryOptions } from './querytypes';
+/**
+ * @internal
+ */
+export type StreamingOptions = AnalyticsQueryOptions | QueryOptions;
+/**
+ * Generates an absolute Unix epoch time with nanosecond precision.
+ * @internal
+ */
+export declare function getEpochHiResTime(): [number, number];
+/**
+ * @internal
+ */
+export declare function hiResTimeToMicros(hrTime: HiResTime): number;
+/**
+ * @internal
+ */
+export declare function getHiResTimeDelta(start: HiResTime, end: HiResTime): HiResTime;
+/**
+ * @internal
+ */
+export declare function millisToHiResTime(millis: number): HiResTime;
+/**
+ * @internal
+ */
+export declare function getLatestTime(timeA: HiResTime, timeB: HiResTime): HiResTime;
+/**
+ * @internal
+ */
+export declare function getCoreSpanEndTime(coreSpanEndTime: HiResTime): HiResTime;
+/**
+ * @internal
+ */
+export declare function timeInputToHiResTime(input?: TimeInput): HiResTime;
+/**
+ * @internal
+ */
+export declare function getAttributesForKeyValueOpType(opType: KeyValueOp, cppDocId: CppDocumentId, durability?: CppDurabilityLevel): {
+    [key: string]: AttributeValue;
+};
+/**
+ * @internal
+ */
+export interface HttpOpAttributesOptions {
+    statement?: string;
+    queryOptions?: StreamingOptions;
+    queryContext?: string;
+    bucketName?: string;
+    scopeName?: string;
+    collectionName?: string;
+}
+/**
+ * @internal
+ */
+export declare function getAttributesForHttpOpType(opType: HttpOpType, options?: HttpOpAttributesOptions): {
+    [key: string]: AttributeValue;
+};

package/dist/observabilityutilities.js

@@ -0,0 +1,175 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAttributesForHttpOpType = exports.getAttributesForKeyValueOpType = exports.timeInputToHiResTime = exports.getCoreSpanEndTime = exports.getLatestTime = exports.millisToHiResTime = exports.getHiResTimeDelta = exports.hiResTimeToMicros = exports.getEpochHiResTime = void 0;
+const binding_1 = __importDefault(require("./binding"));
+const observabilitytypes_1 = require("./observabilitytypes");
+// Define standard time constants
+const MILLIS_PER_SECOND = 1000;
+const NANOS_PER_SECOND = 1000000000;
+const MICROS_PER_SECOND = 1000000;
+const NANOS_PER_MILLI = 1000000;
+// Take a snapshot the moment the SDK loads
+const TIME_ORIGIN_MS = Date.now();
+const HRTIME_ORIGIN = process.hrtime();
+// Convert the absolute origin into [seconds, nanoseconds]
+const ORIGIN_SECONDS = Math.floor(TIME_ORIGIN_MS / MILLIS_PER_SECOND);
+const ORIGIN_NANOS = (TIME_ORIGIN_MS % MILLIS_PER_SECOND) * NANOS_PER_MILLI;
+/**
+ * Generates an absolute Unix epoch time with nanosecond precision.
+ * @internal
+ */
+function getEpochHiResTime() {
+    // Get the current monotonic time
+    const nowHrTime = process.hrtime();
+    // Calculate exactly how much time has passed since our anchor snapshot
+    const [deltaSeconds, deltaNanos] = getHiResTimeDelta(HRTIME_ORIGIN, nowHrTime);
+    // Add the high-res delta to our absolute epoch anchor
+    let epochSeconds = ORIGIN_SECONDS + deltaSeconds;
+    let epochNanos = ORIGIN_NANOS + deltaNanos;
+    // Handle nanosecond overflow (if nanos exceed 1 second, carry it over)
+    if (epochNanos >= NANOS_PER_SECOND) {
+        epochSeconds += 1;
+        epochNanos -= NANOS_PER_SECOND;
+    }
+    return [epochSeconds, epochNanos];
+}
+exports.getEpochHiResTime = getEpochHiResTime;
+/**
+ * @internal
+ */
+function hiResTimeToMicros(hrTime) {
+    return hrTime[0] * MICROS_PER_SECOND + hrTime[1] / MILLIS_PER_SECOND;
+}
+exports.hiResTimeToMicros = hiResTimeToMicros;
+/**
+ * @internal
+ */
+function getHiResTimeDelta(start, end) {
+    let seconds = end[0] - start[0];
+    let nanoseconds = end[1] - start[1];
+    // Handle nanosecond underflow
+    if (nanoseconds < 0) {
+        seconds -= 1;
+        nanoseconds += NANOS_PER_SECOND;
+    }
+    return [seconds, nanoseconds];
+}
+exports.getHiResTimeDelta = getHiResTimeDelta;
+/**
+ * @internal
+ */
+function millisToHiResTime(millis) {
+    const seconds = Math.floor(millis / MILLIS_PER_SECOND);
+    const remainingMillis = millis - seconds * MILLIS_PER_SECOND;
+    const nanoseconds = remainingMillis * MICROS_PER_SECOND;
+    return [seconds, nanoseconds];
+}
+exports.millisToHiResTime = millisToHiResTime;
+/**
+ * @internal
+ */
+function getLatestTime(timeA, timeB) {
+    // first compare seconds
+    if (timeA[0] > timeB[0]) {
+        return timeA;
+    }
+    if (timeA[0] < timeB[0]) {
+        return timeB;
+    }
+    // If seconds are exactly the same, compare the nanoseconds
+    if (timeA[1] >= timeB[1]) {
+        return timeA;
+    }
+    return timeB;
+}
+exports.getLatestTime = getLatestTime;
+/**
+ * @internal
+ */
+function getCoreSpanEndTime(coreSpanEndTime) {
+    // Mitigate Node.js vs C++ clock skew. A parent span must fully encapsulate
+    // its children, so we ensure the parent ends at or after the core child's end time.
+    const currentTime = timeInputToHiResTime();
+    return getLatestTime(currentTime, coreSpanEndTime);
+}
+exports.getCoreSpanEndTime = getCoreSpanEndTime;
+/**
+ * @internal
+ */
+function timeInputToHiResTime(input) {
+    if (typeof input === 'undefined') {
+        return getEpochHiResTime();
+    }
+    // If a Date object is provided, extract the epoch milliseconds
+    if (input instanceof Date) {
+        return millisToHiResTime(input.getTime());
+    }
+    // If a number is provided, assume it is epoch milliseconds
+    if (typeof input === 'number') {
+        return millisToHiResTime(input);
+    }
+    return input;
+}
+exports.timeInputToHiResTime = timeInputToHiResTime;
+/**
+ * @internal
+ */
+function getAttributesForKeyValueOpType(opType, cppDocId, durability) {
+    const attributes = {
+        [observabilitytypes_1.OpAttributeName.SystemName]: 'couchbase',
+        [observabilitytypes_1.OpAttributeName.Service]: (0, observabilitytypes_1.serviceNameFromOpType)(opType),
+        [observabilitytypes_1.OpAttributeName.OperationName]: opType,
+        [observabilitytypes_1.OpAttributeName.BucketName]: cppDocId.bucket,
+        [observabilitytypes_1.OpAttributeName.ScopeName]: cppDocId.scope,
+        [observabilitytypes_1.OpAttributeName.CollectionName]: cppDocId.collection,
+    };
+    if (durability && durability != binding_1.default.durability_level.none) {
+        if (durability === binding_1.default.durability_level.majority) {
+            attributes[observabilitytypes_1.OpAttributeName.DurabilityLevel] = 'majority';
+        }
+        else if (durability === binding_1.default.durability_level.majority_and_persist_to_active) {
+            attributes[observabilitytypes_1.OpAttributeName.DurabilityLevel] =
+                'majority_and_persist_to_active';
+        }
+        else if (durability === binding_1.default.durability_level.persist_to_majority) {
+            attributes[observabilitytypes_1.OpAttributeName.DurabilityLevel] = 'persist_to_majority';
+        }
+    }
+    return attributes;
+}
+exports.getAttributesForKeyValueOpType = getAttributesForKeyValueOpType;
+/**
+ * @internal
+ */
+function getAttributesForHttpOpType(opType, options) {
+    var _a;
+    const attributes = {
+        [observabilitytypes_1.OpAttributeName.SystemName]: 'couchbase',
+        [observabilitytypes_1.OpAttributeName.Service]: (0, observabilitytypes_1.serviceNameFromOpType)(opType),
+        [observabilitytypes_1.OpAttributeName.OperationName]: opType,
+    };
+    if (((_a = options === null || options === void 0 ? void 0 : options.queryOptions) === null || _a === void 0 ? void 0 : _a.parameters) && options.statement) {
+        attributes[observabilitytypes_1.OpAttributeName.QueryStatement] = options.statement;
+    }
+    if (options === null || options === void 0 ? void 0 : options.bucketName) {
+        attributes[observabilitytypes_1.OpAttributeName.BucketName] = options.bucketName;
+    }
+    if (options === null || options === void 0 ? void 0 : options.scopeName) {
+        attributes[observabilitytypes_1.OpAttributeName.ScopeName] = options.scopeName;
+    }
+    if (options === null || options === void 0 ? void 0 : options.collectionName) {
+        attributes[observabilitytypes_1.OpAttributeName.CollectionName] = options.collectionName;
+    }
+    if (options === null || options === void 0 ? void 0 : options.queryContext) {
+        const [bucketName, scopeName] = options.queryContext
+            .split('.')
+            .map((str) => str.replace(/`/g, ''));
+        attributes[observabilitytypes_1.OpAttributeName.BucketName] = bucketName;
+        attributes[observabilitytypes_1.OpAttributeName.ScopeName] = scopeName;
+    }
+    return attributes;
+}
+exports.getAttributesForHttpOpType = getAttributesForHttpOpType;

package/dist/otelmeter.d.ts

@@ -0,0 +1,51 @@
+import { Meter, ValueRecorder } from './metrics';
+import type { Histogram as OTelHistogram, Meter as OTelMeter, MeterProvider as OTelMeterProvider } from '@opentelemetry/api';
+/**
+ * Wrapper class for OpenTelemetry Histogram that implements ValueRecorder interface.
+ */
+export declare class OTelValueRecorder implements ValueRecorder {
+    private _histogram;
+    private _tags;
+    private _unit?;
+    /**
+     * Creates an instance of OTelValueRecorder.
+     *
+     * @param histogram - OpenTelemetry Histogram to record values.
+     * @param tags - Tags to associate with recorded values.
+     * @param unit - Optional unit of measurement (e.g., 's' for seconds). If provided, it indicates that the recorded values
+     *                should be converted from microseconds to seconds.
+     */
+    constructor(histogram: OTelHistogram, tags: Record<string, string>, unit?: string);
+    /**
+     * Records a value with the associated tags.
+     *
+     * @param value - The numeric value to record.
+     */
+    recordValue(value: number): void;
+}
+/**
+ * Wrapper class for OpenTelemetry Meter that implements Meter interface.
+ */
+export declare class OTelWrapperMeter implements Meter {
+    private _otelMeter;
+    private _histograms;
+    /**
+     * Creates an instance of OTelWrapperMeter.
+     *
+     * @param meter - OpenTelemetry Meter to wrap.
+     */
+    constructor(meter: OTelMeter);
+    /**
+     * Creates a ValueRecorder for recording metric values.
+     *
+     * @param name - The name of the metric.
+     * @param tags - Tags to associate with recorded values.
+     * @returns A ValueRecorder instance for recording metrics.
+     */
+    valueRecorder(name: string, tags: Record<string, any>): ValueRecorder;
+}
+/**
+ * Creates an OpenTelemetry wrapper meter.
+ * Throws an Error if @opentelemetry/api is not installed.
+ */
+export declare function getOTelMeter(provider?: OTelMeterProvider): Meter;

package/dist/otelmeter.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOTelMeter = exports.OTelWrapperMeter = exports.OTelValueRecorder = void 0;
+const version_1 = require("./version");
+/* eslint-enable n/no-missing-import */
+// Dynamic Runtime Require (Bundler-safe)
+let otelApi = null;
+let HAS_OTEL = false;
+try {
+    // Hiding the string prevents Webpack/Vite from throwing missing dependency errors
+    const moduleName = '@opentelemetry/api';
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    otelApi = require(moduleName);
+    HAS_OTEL = true;
+}
+catch (_err) {
+    HAS_OTEL = false;
+}
+/**
+ * Wrapper class for OpenTelemetry Histogram that implements ValueRecorder interface.
+ */
+class OTelValueRecorder {
+    /**
+     * Creates an instance of OTelValueRecorder.
+     *
+     * @param histogram - OpenTelemetry Histogram to record values.
+     * @param tags - Tags to associate with recorded values.
+     * @param unit - Optional unit of measurement (e.g., 's' for seconds). If provided, it indicates that the recorded values
+     *                should be converted from microseconds to seconds.
+     */
+    constructor(histogram, tags, unit) {
+        this._histogram = histogram;
+        this._tags = tags;
+        this._unit = unit;
+    }
+    /**
+     * Records a value with the associated tags.
+     *
+     * @param value - The numeric value to record.
+     */
+    recordValue(value) {
+        // The SDK records value in micros and will place a special __unit tag in the tags set to 's'
+        // So self._unit == 's' is indication that we should convert from micros to seconds
+        const finalValue = this._unit === 's' ? value / 1000000 : value;
+        this._histogram.record(finalValue, this._tags);
+    }
+}
+exports.OTelValueRecorder = OTelValueRecorder;
+/**
+ * Wrapper class for OpenTelemetry Meter that implements Meter interface.
+ */
+class OTelWrapperMeter {
+    /**
+     * Creates an instance of OTelWrapperMeter.
+     *
+     * @param meter - OpenTelemetry Meter to wrap.
+     */
+    constructor(meter) {
+        this._otelMeter = meter;
+        this._histograms = {};
+    }
+    /**
+     * Creates a ValueRecorder for recording metric values.
+     *
+     * @param name - The name of the metric.
+     * @param tags - Tags to associate with recorded values.
+     * @returns A ValueRecorder instance for recording metrics.
+     */
+    valueRecorder(name, tags) {
+        const localTags = tags ? { ...tags } : {};
+        const unit = localTags.__unit;
+        delete localTags.__unit;
+        if (!this._histograms[name]) {
+            this._histograms[name] = this._otelMeter.createHistogram(name, {
+                unit: unit,
+            });
+        }
+        const histogram = this._histograms[name];
+        return new OTelValueRecorder(histogram, localTags, unit);
+    }
+}
+exports.OTelWrapperMeter = OTelWrapperMeter;
+/**
+ * Creates an OpenTelemetry wrapper meter.
+ * Throws an Error if @opentelemetry/api is not installed.
+ */
+function getOTelMeter(provider) {
+    if (!HAS_OTEL || !otelApi) {
+        throw new Error('OpenTelemetry is not installed. Please install it with: ' +
+            'npm install @opentelemetry/api');
+    }
+    const pkgName = `${version_1.SDK_NAME}-nodejs-client`;
+    const pkgVersion = version_1.SDK_VERSION;
+    if (provider) {
+        return new OTelWrapperMeter(provider.getMeter(pkgName, pkgVersion));
+    }
+    // Fallback to the global OpenTelemetry metrics provider
+    return new OTelWrapperMeter(otelApi.metrics.getMeter(pkgName, pkgVersion));
+}
+exports.getOTelMeter = getOTelMeter;

package/dist/oteltracer.d.ts

@@ -0,0 +1,69 @@
+import { AttributeValue, SpanStatus, TimeInput } from './observabilitytypes';
+import { RequestSpan, RequestTracer } from './tracing';
+import type { Tracer as OTelTracer, TracerProvider as OTelTracerProvider, Span as OTelSpan } from '@opentelemetry/api';
+/**
+ * Wrapper class for OpenTelemetry Span that implements RequestSpan interface.
+ */
+export declare class OTelWrapperSpan implements RequestSpan {
+    readonly name: string;
+    readonly _otelSpan: OTelSpan;
+    /**
+     * Creates an instance of OTelWrapperSpan.
+     *
+     * @param otelSpan - OpenTelemetry Span to wrap.
+     * @param name - The name of the span.
+     */
+    constructor(otelSpan: OTelSpan, name: string);
+    /**
+     * Sets an attribute on the span.
+     *
+     * @param key - The attribute key.
+     * @param value - The attribute value.
+     */
+    setAttribute(key: string, value: AttributeValue): void;
+    /**
+     * Adds an event to the span.
+     *
+     * @param key - The event key.
+     * @param startTime - Optional timestamp for the event.
+     */
+    addEvent(key: string, startTime?: TimeInput): void;
+    /**
+     * Sets the status of the span.
+     *
+     * @param status - The SpanStatus to set.
+     */
+    setStatus(status: SpanStatus): void;
+    /**
+     * Ends the span.
+     *
+     * @param endTime - Optional timestamp for when the span ended.
+     */
+    end(endTime?: TimeInput): void;
+}
+/**
+ * Wrapper class for OpenTelemetry Tracer that implements RequestTracer interface.
+ */
+export declare class OTelWrapperTracer implements RequestTracer {
+    private _tracer;
+    /**
+     * Creates an instance of OTelWrapperTracer.
+     *
+     * @param tracer - OpenTelemetry Tracer to wrap.
+     */
+    constructor(tracer: OTelTracer);
+    /**
+     * Creates a new request span, optionally with a parent span.
+     *
+     * @param name - The name of the span.
+     * @param parentSpan - Optional parent span for this request.
+     * @param startTime - Optional timestamp for when the span started.
+     * @returns A RequestSpan instance for the new span.
+     */
+    requestSpan(name: string, parentSpan?: RequestSpan, startTime?: TimeInput): RequestSpan;
+}
+/**
+ * Creates an OpenTelemetry wrapper tracer.
+ * Throws an Error if @opentelemetry/api is not installed.
+ */
+export declare function getOTelTracer(tracerProvider?: OTelTracerProvider): RequestTracer;

package/dist/oteltracer.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOTelTracer = exports.OTelWrapperTracer = exports.OTelWrapperSpan = void 0;
+const observabilitytypes_1 = require("./observabilitytypes");
+const version_1 = require("./version");
+/* eslint-enable n/no-missing-import */
+// Dynamic Runtime Require (Bundler-safe)
+let otelApi = null;
+let HAS_OTEL = false;
+try {
+    // Hiding the string prevents Webpack/Vite from throwing missing dependency errors
+    const moduleName = '@opentelemetry/api';
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    otelApi = require(moduleName);
+    HAS_OTEL = true;
+}
+catch (_err) {
+    HAS_OTEL = false;
+}
+/**
+ * Wrapper class for OpenTelemetry Span that implements RequestSpan interface.
+ */
+class OTelWrapperSpan {
+    /**
+     * Creates an instance of OTelWrapperSpan.
+     *
+     * @param otelSpan - OpenTelemetry Span to wrap.
+     * @param name - The name of the span.
+     */
+    constructor(otelSpan, name) {
+        this._otelSpan = otelSpan;
+        this.name = name;
+    }
+    /**
+     * Sets an attribute on the span.
+     *
+     * @param key - The attribute key.
+     * @param value - The attribute value.
+     */
+    setAttribute(key, value) {
+        this._otelSpan.setAttribute(key, value);
+    }
+    /**
+     * Adds an event to the span.
+     *
+     * @param key - The event key.
+     * @param startTime - Optional timestamp for the event.
+     */
+    addEvent(key, startTime) {
+        this._otelSpan.addEvent(key, startTime);
+    }
+    /**
+     * Sets the status of the span.
+     *
+     * @param status - The SpanStatus to set.
+     */
+    setStatus(status) {
+        // We use the non-null assertion (!) because this class cannot be
+        // instantiated unless otelApi successfully loaded.
+        let otelCode = otelApi.SpanStatusCode.UNSET;
+        if (status.code === observabilitytypes_1.SpanStatusCode.OK) {
+            otelCode = otelApi.SpanStatusCode.OK;
+        }
+        else if (status.code === observabilitytypes_1.SpanStatusCode.ERROR) {
+            otelCode = otelApi.SpanStatusCode.ERROR;
+        }
+        this._otelSpan.setStatus({
+            code: otelCode,
+            message: status.message,
+        });
+    }
+    /**
+     * Ends the span.
+     *
+     * @param endTime - Optional timestamp for when the span ended.
+     */
+    end(endTime) {
+        this._otelSpan.end(endTime);
+    }
+}
+exports.OTelWrapperSpan = OTelWrapperSpan;
+/**
+ * Wrapper class for OpenTelemetry Tracer that implements RequestTracer interface.
+ */
+class OTelWrapperTracer {
+    /**
+     * Creates an instance of OTelWrapperTracer.
+     *
+     * @param tracer - OpenTelemetry Tracer to wrap.
+     */
+    constructor(tracer) {
+        this._tracer = tracer;
+    }
+    /**
+     * Creates a new request span, optionally with a parent span.
+     *
+     * @param name - The name of the span.
+     * @param parentSpan - Optional parent span for this request.
+     * @param startTime - Optional timestamp for when the span started.
+     * @returns A RequestSpan instance for the new span.
+     */
+    requestSpan(name, parentSpan, startTime) {
+        // Grab the current active context from OTel
+        let context = otelApi.context.active();
+        // If the user passed in a parent span, and it is one of our wrappers,
+        // extract the raw OTel span and inject it into a new context.
+        if (parentSpan && parentSpan instanceof OTelWrapperSpan) {
+            context = otelApi.trace.setSpan(context, parentSpan._otelSpan);
+        }
+        // Start the new span using the safely mapped inputs
+        const span = this._tracer.startSpan(name, {
+            startTime: startTime,
+            kind: otelApi.SpanKind.CLIENT,
+        }, context);
+        return new OTelWrapperSpan(span, name);
+    }
+}
+exports.OTelWrapperTracer = OTelWrapperTracer;
+/**
+ * Creates an OpenTelemetry wrapper tracer.
+ * Throws an Error if @opentelemetry/api is not installed.
+ */
+function getOTelTracer(tracerProvider) {
+    if (!HAS_OTEL || !otelApi) {
+        throw new Error('OpenTelemetry is not installed. Please install it with: ' +
+            'npm install @opentelemetry/api');
+    }
+    const pkgName = `com.couchbase.client/nodejs`;
+    const pkgVersion = version_1.SDK_VERSION;
+    let tracer;
+    if (tracerProvider) {
+        // Use the explicit provider they passed in
+        tracer = tracerProvider.getTracer(pkgName, pkgVersion);
+    }
+    else {
+        // Fallback to the global OpenTelemetry provider
+        tracer = otelApi.trace.getTracer(pkgName, pkgVersion);
+    }
+    return new OTelWrapperTracer(tracer);
+}
+exports.getOTelTracer = getOTelTracer;

package/dist/queryexecutor.d.ts

@@ -1,5 +1,7 @@
 import { CppError, CppQueryResponse } from './binding';
 import { Cluster } from './cluster';
+import { ObservableRequestHandler } from './observabilityhandler';
+import { ObservabilityInstruments } from './observabilitytypes';
 import { QueryMetaData, QueryOptions, QueryResult } from './querytypes';
 import { StreamableRowPromise } from './streamablepromises';
 /**
@@ -14,7 +16,21 @@ export declare class QueryExecutor {
     /**
      * @internal
      */
+    get observabilityInstruments(): ObservabilityInstruments;
+    /**
+     * @internal
+     */
+    static _processQueryResponse<TRow>(emitter: StreamableRowPromise<QueryResult<TRow>, TRow, QueryMetaData>, err: Error | null, resp: CppQueryResponse, obsReqHandler?: ObservableRequestHandler): void;
+    /**
+     * @internal
+     *
+     * Used by transactions (observability currently not available for transactions)
+     */
     static execute<TRow = any>(exec: (callback: (err: CppError | null, resp: CppQueryResponse) => void) => void): StreamableRowPromise<QueryResult<TRow>, TRow, QueryMetaData>;
+    /**
+     * @internal
+     */
+    static executePromise<TRow = any>(queryPromise: Promise<[Error | null, CppQueryResponse]>, obsReqHandler: ObservableRequestHandler): StreamableRowPromise<QueryResult<TRow>, TRow, QueryMetaData>;
     /**
      * @internal
      */