@perses-dev/greptimedb-plugin 0.1.0-beta.0

package/lib/cjs/queries/greptimedb-trace-query/get-greptimedb-trace-data.js

@@ -0,0 +1,518 @@
+// Copyright The Perses Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get getGreptimeDBTraceData () {
+        return getGreptimeDBTraceData;
+    },
+    get toNanoString () {
+        return toNanoString;
+    }
+});
+const _pluginsystem = require("@perses-dev/plugin-system");
+const _trace = /*#__PURE__*/ _interop_require_wildcard(require("@perses-dev/spec/dist/dashboard/query-type/otlp/trace/v1/trace"));
+const _constants = require("../constants");
+const _greptimedbquerydatamodel = require("../greptimedb-query-data-model");
+const _tracequerysql = require("./trace-query-sql");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const getGreptimeDBTraceData = async (spec, context)=>{
+    const rawQuery = (0, _pluginsystem.replaceVariables)(spec.query ?? '', context.variableState).trim();
+    if (rawQuery.length === 0) {
+        return {
+            searchResult: []
+        };
+    }
+    const datasourceSelector = normalizeDatasourceSelector(spec.datasource);
+    const client = await context.datasourceStore.getDatasourceClient(datasourceSelector ?? _constants.DEFAULT_DATASOURCE);
+    const start = context.absoluteTimeRange?.start.getTime().toString() ?? '0';
+    const end = context.absoluteTimeRange?.end.getTime().toString() ?? '0';
+    const response = await client.query({
+        query: rawQuery,
+        start,
+        end
+    });
+    if (response.status === 'error') {
+        throw new Error(response.error ?? 'GreptimeDB trace query failed');
+    }
+    const records = (0, _greptimedbquerydatamodel.normalizeRecords)(response.data);
+    const isDetailQuery = (0, _tracequerysql.isLikelyTraceDetailSQL)(rawQuery);
+    if (isDetailQuery && isTraceDetailsResult(records)) {
+        return {
+            trace: convertRowsToTrace(records),
+            metadata: {
+                executedQueryString: rawQuery
+            }
+        };
+    }
+    return {
+        searchResult: buildSearchResult(records),
+        metadata: {
+            executedQueryString: rawQuery
+        }
+    };
+};
+function normalizeDatasourceSelector(datasource) {
+    if (!datasource) {
+        return undefined;
+    }
+    // Deep links may carry an empty datasource name. Treat it as "default datasource for this kind".
+    if (typeof datasource.name === 'string' && datasource.name.trim() === '') {
+        const { kind } = datasource;
+        return kind ? {
+            kind
+        } : undefined;
+    }
+    return datasource;
+}
+function buildColumnIndexMap(columns) {
+    const map = {};
+    (columns ?? []).forEach((c, index)=>{
+        map[c.name.toLowerCase()] = index;
+    });
+    return map;
+}
+/** GreptimeDB /v1/sql includes data_type on every column_schemas entry. */ function getColumnDataType(columns, index) {
+    const column = columns[index];
+    if (!column) {
+        throw new Error(`GreptimeDB SQL response missing column at index ${index}`);
+    }
+    const dataType = column.data_type;
+    if (!dataType) {
+        throw new Error(`GreptimeDB SQL response missing data_type for column "${column.name}"`);
+    }
+    return dataType;
+}
+function isTraceDetailsResult(records) {
+    const columns = records?.schema?.column_schemas ?? [];
+    if (columns.length === 0) return false;
+    const map = buildColumnIndexMap(columns);
+    // Trace detail queries should return span-level columns for gantt visualization.
+    return map.trace_id !== undefined && map.span_id !== undefined;
+}
+function getCell(row, map, names) {
+    for (const name of names){
+        const idx = map[name.toLowerCase()];
+        if (idx !== undefined) {
+            return row[idx];
+        }
+    }
+    return undefined;
+}
+function getString(value) {
+    if (value === null || value === undefined) return undefined;
+    return String(value);
+}
+function getNumber(value) {
+    if (value === null || value === undefined) return undefined;
+    if (typeof value === 'number') return Number.isFinite(value) ? value : undefined;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function isErrorStatus(value) {
+    const normalized = String(value ?? '').trim().toUpperCase();
+    return normalized === 'STATUS_CODE_ERROR' || normalized === 'ERROR' || normalized === '2';
+}
+function getDurationMs(row, columns, map) {
+    const durationMs = getNumber(getCell(row, map, [
+        'duration_ms'
+    ]));
+    if (durationMs !== undefined) return durationMs;
+    const durationNano = getNumber(getCell(row, map, [
+        'duration_nano',
+        'duration_ns'
+    ]));
+    if (durationNano !== undefined) return durationNano / 1_000_000;
+    const startIndex = map.timestamp ?? map.start_time ?? map.start_time_unix_nano;
+    const endIndex = map.timestamp_end ?? map.end_time ?? map.end_time_unix_nano;
+    if (columns && startIndex !== undefined && endIndex !== undefined) {
+        const startMs = (0, _greptimedbquerydatamodel.toTimestampMs)(row[startIndex], getColumnDataType(columns, startIndex));
+        const endMs = (0, _greptimedbquerydatamodel.toTimestampMs)(row[endIndex], getColumnDataType(columns, endIndex));
+        if (startMs !== null && endMs !== null) return Math.max(0, endMs - startMs);
+    }
+    return 0;
+}
+function getStartMs(row, columns, map) {
+    const candidates = [
+        'timestamp',
+        'start_time',
+        'start_time_unix_nano',
+        'start_time_unix_ns',
+        'start_time_unix_ms',
+        'start_time_unix'
+    ];
+    for (const c of candidates){
+        const idx = map[c];
+        if (idx === undefined) continue;
+        if (!columns) continue;
+        const ts = (0, _greptimedbquerydatamodel.toTimestampMs)(row[idx], getColumnDataType(columns, idx));
+        if (ts !== null) return ts;
+    }
+    return undefined;
+}
+function getEndMs(row, columns, map) {
+    const candidates = [
+        'timestamp_end',
+        'end_time',
+        'end_time_unix_nano',
+        'end_time_unix_ns',
+        'end_time_unix_ms'
+    ];
+    for (const c of candidates){
+        const idx = map[c];
+        if (idx === undefined) continue;
+        if (!columns) continue;
+        const ts = (0, _greptimedbquerydatamodel.toTimestampMs)(row[idx], getColumnDataType(columns, idx));
+        if (ts !== null) return ts;
+    }
+    return undefined;
+}
+function buildSearchResult(records) {
+    const columns = records?.schema?.column_schemas ?? [];
+    const rows = records?.rows ?? [];
+    if (!columns.length || !rows.length) return [];
+    const map = buildColumnIndexMap(columns);
+    const traceMap = new Map();
+    rows.forEach((row)=>{
+        const traceId = getString(getCell(row, map, [
+            'trace_id',
+            'traceid',
+            'traceId'
+        ]));
+        if (!traceId) return;
+        const startMs = getStartMs(row, columns, map);
+        const durationMs = getDurationMs(row, columns, map);
+        const endMs = getEndMs(row, columns, map) ?? (startMs !== undefined ? startMs + durationMs : undefined);
+        const serviceName = getString(getCell(row, map, [
+            'service_name',
+            'root_service_name'
+        ])) ?? 'unknown';
+        const spanName = getString(getCell(row, map, [
+            'span_name',
+            'root_trace_name',
+            'operation_name',
+            'name'
+        ])) ?? '(unknown span)';
+        const parentSpanId = getString(getCell(row, map, [
+            'parent_span_id',
+            'parentspanid',
+            'parentSpanId'
+        ]));
+        const existing = traceMap.get(traceId);
+        if (!existing) {
+            traceMap.set(traceId, {
+                traceId,
+                startTimeUnixMs: startMs ?? 0,
+                endTimeUnixMs: endMs ?? startMs ?? 0,
+                rootServiceName: serviceName,
+                rootTraceName: spanName,
+                serviceStats: {
+                    [serviceName]: {
+                        spanCount: 1,
+                        errorCount: isErrorStatus(getCell(row, map, [
+                            'span_status_code',
+                            'status_code'
+                        ])) ? 1 : 0
+                    }
+                }
+            });
+            return;
+        }
+        if (startMs !== undefined) {
+            existing.startTimeUnixMs = existing.startTimeUnixMs === 0 ? startMs : Math.min(existing.startTimeUnixMs, startMs);
+        }
+        if (endMs !== undefined) {
+            existing.endTimeUnixMs = Math.max(existing.endTimeUnixMs, endMs);
+        }
+        if (!parentSpanId) {
+            existing.rootTraceName = spanName;
+            existing.rootServiceName = serviceName;
+        }
+        if (!existing.serviceStats[serviceName]) {
+            existing.serviceStats[serviceName] = {
+                spanCount: 0,
+                errorCount: 0
+            };
+        }
+        existing.serviceStats[serviceName].spanCount += 1;
+        if (isErrorStatus(getCell(row, map, [
+            'span_status_code',
+            'status_code'
+        ]))) {
+            existing.serviceStats[serviceName].errorCount += 1;
+        }
+    });
+    return Array.from(traceMap.values()).map((entry)=>({
+            traceId: entry.traceId,
+            startTimeUnixMs: entry.startTimeUnixMs,
+            durationMs: Math.max(0, entry.endTimeUnixMs - entry.startTimeUnixMs),
+            rootServiceName: entry.rootServiceName,
+            rootTraceName: entry.rootTraceName,
+            serviceStats: entry.serviceStats
+        })).sort((a, b)=>b.startTimeUnixMs - a.startTimeUnixMs);
+}
+function isIntegerGreptimeDataType(dataType) {
+    const normalized = dataType.toLowerCase();
+    return normalized.includes('int') || normalized.includes('uint') || normalized === 'bigint';
+}
+/**
+ * span_events JSON only: OTLP timeUnixNano is already nanoseconds (not a GreptimeDB TIMESTAMP column).
+ * @see https://docs.greptime.com/user-guide/traces/data-model/
+ */ function otlpEventTimeToNanoString(value) {
+    if (value === undefined || value === null) return undefined;
+    const raw = getNumber(value);
+    if (raw !== undefined) return String(BigInt(Math.trunc(raw)));
+    const dateMs = new Date(String(value)).getTime();
+    if (!Number.isNaN(dateMs)) return String(BigInt(Math.trunc(dateMs)) * 1_000_000n);
+    return undefined;
+}
+function toNanoString(value, dataType) {
+    if (value === undefined || value === null) return undefined;
+    const raw = getNumber(value);
+    if (raw === undefined) return undefined;
+    const normalized = dataType.toLowerCase();
+    if (normalized.includes('nanosecond')) return String(BigInt(Math.trunc(raw)));
+    if (normalized.includes('microsecond')) return String(BigInt(Math.trunc(raw)) * 1000n);
+    if (normalized.includes('millisecond')) return String(BigInt(Math.trunc(raw)) * 1_000_000n);
+    if (normalized.includes('second')) return String(BigInt(Math.trunc(raw)) * 1_000_000_000n);
+    if (isIntegerGreptimeDataType(dataType)) return String(BigInt(Math.trunc(raw)));
+    throw new Error(`Unsupported GreptimeDB data_type: ${dataType}`);
+}
+function parseJsonArray(value) {
+    if (Array.isArray(value)) return value;
+    if (typeof value === 'string') {
+        try {
+            const parsed = JSON.parse(value);
+            return Array.isArray(parsed) ? parsed : [];
+        } catch  {
+            return [];
+        }
+    }
+    return [];
+}
+function toAnyValue(value) {
+    return {
+        stringValue: typeof value === 'string' ? value : JSON.stringify(value)
+    };
+}
+function toKeyValue(key, value) {
+    return {
+        key,
+        value: toAnyValue(value)
+    };
+}
+function parseStatusCode(value) {
+    const normalized = String(value ?? '').trim().toUpperCase();
+    if (!normalized) return undefined;
+    if (normalized === 'STATUS_CODE_OK' || normalized === 'OK' || normalized === '1') {
+        return _trace.StatusCodeOk;
+    }
+    if (normalized === 'STATUS_CODE_ERROR' || normalized === 'ERROR' || normalized === '2') {
+        return _trace.StatusCodeError;
+    }
+    return _trace.StatusCodeUnset;
+}
+function convertRowsToTrace(records) {
+    const columns = records?.schema?.column_schemas ?? [];
+    const rows = records?.rows ?? [];
+    if (!columns.length || !rows.length) return {
+        resourceSpans: []
+    };
+    const map = buildColumnIndexMap(columns);
+    const spanColumns = columns.filter((col)=>col.name.startsWith('span_attributes.'));
+    const resourceColumns = columns.filter((col)=>col.name.startsWith('resource_attributes.'));
+    const byService = new Map();
+    rows.forEach((row)=>{
+        const traceId = getString(getCell(row, map, [
+            'trace_id',
+            'traceid',
+            'traceId'
+        ]));
+        const spanId = getString(getCell(row, map, [
+            'span_id',
+            'spanid',
+            'spanId'
+        ]));
+        if (!traceId || !spanId) return;
+        const parentSpanId = getString(getCell(row, map, [
+            'parent_span_id',
+            'parentspanid',
+            'parentSpanId'
+        ]));
+        const name = getString(getCell(row, map, [
+            'span_name',
+            'name',
+            'operation_name'
+        ])) ?? '(unknown span)';
+        const kind = getString(getCell(row, map, [
+            'span_kind',
+            'kind'
+        ])) ?? 'SPAN_KIND_UNSPECIFIED';
+        const serviceName = getString(getCell(row, map, [
+            'service_name'
+        ])) ?? 'unknown';
+        const scopeName = getString(getCell(row, map, [
+            'scope_name'
+        ])) ?? '';
+        const scopeVersion = getString(getCell(row, map, [
+            'scope_version'
+        ])) ?? '';
+        const startIndex = map.timestamp ?? map.start_time ?? map.start_time_unix_nano;
+        const endIndex = map.timestamp_end ?? map.end_time ?? map.end_time_unix_nano;
+        const durationIndex = map.duration_nano ?? map.duration_ns;
+        const startTimeUnixNano = startIndex !== undefined ? toNanoString(row[startIndex], getColumnDataType(columns, startIndex)) ?? '0' : '0';
+        const endTimeUnixNano = (endIndex !== undefined ? toNanoString(row[endIndex], getColumnDataType(columns, endIndex)) ?? '0' : undefined) ?? (durationIndex !== undefined ? String(BigInt(startTimeUnixNano) + BigInt(toNanoString(row[durationIndex], getColumnDataType(columns, durationIndex)) ?? '0')) : startTimeUnixNano);
+        const spanAttributes = spanColumns.map((c)=>{
+            const idx = map[c.name.toLowerCase()];
+            if (idx === undefined) return undefined;
+            const value = row[idx];
+            if (value === undefined || value === null || value === '') return undefined;
+            return toKeyValue(c.name.replace(/^span_attributes\./, ''), value);
+        }).filter((v)=>v !== undefined);
+        // span_events / span_links: JSON columns (data_type Json). Only events need OTLP time parsing.
+        const spanEvents = parseJsonArray(getCell(row, map, [
+            'span_events'
+        ])).map((event)=>{
+            const e = event;
+            const eventTime = otlpEventTimeToNanoString(e.timeUnixNano ?? e.time_unix_nano) ?? startTimeUnixNano;
+            const eventName = getString(e.name) ?? 'event';
+            const attrs = e.attributes;
+            const attributes = attrs ? Object.entries(attrs).map(([k, v])=>toKeyValue(k, v)) : [];
+            return {
+                timeUnixNano: eventTime,
+                name: eventName,
+                attributes
+            };
+        });
+        const spanLinks = parseJsonArray(getCell(row, map, [
+            'span_links'
+        ])).map((link)=>{
+            const l = link;
+            const attrs = l.attributes;
+            const attributes = attrs ? Object.entries(attrs).map(([k, v])=>toKeyValue(k, v)) : [];
+            return {
+                traceId: getString(l.traceId ?? l.trace_id) ?? '',
+                spanId: getString(l.spanId ?? l.span_id) ?? '',
+                attributes
+            };
+        });
+        const statusMessage = getString(getCell(row, map, [
+            'span_status_message'
+        ])) ?? '';
+        const statusCode = parseStatusCode(getCell(row, map, [
+            'span_status_code',
+            'status_code'
+        ]));
+        const span = {
+            traceId,
+            spanId,
+            parentSpanId,
+            name,
+            kind,
+            startTimeUnixNano,
+            endTimeUnixNano,
+            attributes: spanAttributes,
+            events: spanEvents,
+            links: spanLinks,
+            status: {
+                message: statusMessage,
+                code: statusCode
+            }
+        };
+        if (!byService.has(serviceName)) {
+            const resourceAttrs = [
+                toKeyValue('service.name', serviceName)
+            ];
+            resourceColumns.forEach((c)=>{
+                const idx = map[c.name.toLowerCase()];
+                if (idx === undefined) return;
+                const value = row[idx];
+                if (value === undefined || value === null || value === '') return;
+                resourceAttrs.push(toKeyValue(c.name.replace(/^resource_attributes\./, ''), value));
+            });
+            byService.set(serviceName, {
+                resourceAttrs,
+                scopeSpans: new Map()
+            });
+        }
+        const serviceGroup = byService.get(serviceName);
+        const scopeKey = `${scopeName}|${scopeVersion}`;
+        if (!serviceGroup.scopeSpans.has(scopeKey)) {
+            serviceGroup.scopeSpans.set(scopeKey, {
+                scope: {
+                    name: scopeName,
+                    version: scopeVersion
+                },
+                spans: []
+            });
+        }
+        serviceGroup.scopeSpans.get(scopeKey).spans.push(span);
+    });
+    const resourceSpans = Array.from(byService.entries()).map(([_, value])=>({
+            resource: {
+                attributes: value.resourceAttrs
+            },
+            scopeSpans: Array.from(value.scopeSpans.values())
+        }));
+    return {
+        resourceSpans
+    };
+}

package/lib/cjs/queries/greptimedb-trace-query/greptimedb-trace-query-types.js

@@ -0,0 +1,16 @@
+// Copyright The Perses Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

package/lib/cjs/queries/greptimedb-trace-query/index.js

@@ -0,0 +1,33 @@
+// Copyright The Perses Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./GreptimeDBTraceQuery"), exports);
+_export_star(require("./GreptimeDBTraceQueryEditor"), exports);
+_export_star(require("./get-greptimedb-trace-data"), exports);
+_export_star(require("./greptimedb-trace-query-types"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

package/lib/cjs/queries/greptimedb-trace-query/trace-query-sql.js

@@ -0,0 +1,25 @@
+// Copyright The Perses Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "isLikelyTraceDetailSQL", {
+    enumerable: true,
+    get: function() {
+        return isLikelyTraceDetailSQL;
+    }
+});
+function isLikelyTraceDetailSQL(query) {
+    return /where[\s\S]*trace_id\s*=/i.test(query);
+}

package/lib/cjs/queries/index.js

@@ -0,0 +1,32 @@
+// Copyright The Perses Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./greptimedb-time-series-query"), exports);
+_export_star(require("./greptimedb-log-query"), exports);
+_export_star(require("./greptimedb-trace-query"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

package/lib/cjs/queries/query-editor-model.js

@@ -0,0 +1,47 @@
+// Copyright The Perses Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useQueryState", {
+    enumerable: true,
+    get: function() {
+        return useQueryState;
+    }
+});
+const _immer = require("immer");
+const _react = require("react");
+function useQueryState(props) {
+    const { onChange, value } = props;
+    const [query, setQuery] = (0, _react.useState)(value.query || '');
+    const [lastSyncedQuery, setLastSyncedQuery] = (0, _react.useState)(value.query);
+    if (value.query !== lastSyncedQuery) {
+        setQuery(value.query || '');
+        setLastSyncedQuery(value.query);
+    }
+    const handleQueryChange = (e)=>{
+        setQuery(e);
+    };
+    const handleQueryBlur = ()=>{
+        setLastSyncedQuery(query);
+        onChange((0, _immer.produce)(value, (draft)=>{
+            draft.query = query;
+        }));
+    };
+    return {
+        query,
+        handleQueryChange,
+        handleQueryBlur
+    };
+}