@grafana/plugin-ui 0.14.0-dev.1 → 0.14.0

package/dist/esm/index.d.ts

@@ -1,10 +1,12 @@
 import React, { ComponentProps, PureComponent, ReactElement, ReactNode, FunctionComponent, HTMLProps } from 'react';
 import { Input, Segment as Segment$1, monacoTypes, Monaco, ButtonProps, Field, PopoverContent, Switch, SelectCommonProps, InlineLabel } from '@grafana/ui';
-import { DataSourceInstanceSettings, SelectableValue, DataSourceJsonData, VariableSuggestion, TimeRange, DataFrame, MetricFindValue, ThemeSpacingTokens, ScopedVars, VariableModel, DataFrameView, QueryEditorProps as QueryEditorProps$1, DataSourceSettings, RegistryItem, DataSourceApi, Registry, DataQuery as DataQuery$1, PanelData } from '@grafana/data';
+import { DataSourceInstanceSettings, SelectableValue, DataSourceJsonData, VariableSuggestion, TimeRange, DataFrame, MetricFindValue, ThemeSpacingTokens, ScopedVars, DataFrameView, VariableModel, QueryEditorProps as QueryEditorProps$1, DataSourceSettings, RegistryItem, DataSourceApi, Registry, DataQuery as DataQuery$1, PanelData, DataQueryRequest, DataQueryResponse, LoadingState } from '@grafana/data';
 import { DataSourceSrv, DataSourceWithBackend, TemplateSrv } from '@grafana/runtime';
 import { JsonTree } from '@react-awesome-query-builder/ui';
 import { DataQuery } from '@grafana/schema';
+import { SqlLanguage } from 'sql-formatter';
 import { Grammar } from 'prismjs';
+import { Observable } from 'rxjs';
 
 interface QueryEditorRowProps {
     label?: string;
@@ -99,9 +101,6 @@ type Props$q = {
 };
 declare const DataLink: (props: Props$q) => React.JSX.Element;
 
-declare function applyQueryDefaults(q?: SQLQuery): SQLQuery;
-type QueryWithDefaults = ReturnType<typeof applyQueryDefaults>;
-
 declare enum QueryEditorPropertyType {
     String = "string"
 }
@@ -136,6 +135,21 @@ interface QueryEditorFunctionParameterExpression {
     name?: string;
 }
 
+declare enum TokenType {
+    Parenthesis = "delimiter.parenthesis.sql",
+    Whitespace = "white.sql",
+    Keyword = "keyword.sql",
+    Delimiter = "delimiter.sql",
+    Operator = "operator.sql",
+    Identifier = "identifier.sql",
+    IdentifierQuote = "identifier.quote.sql",
+    Type = "type.sql",
+    Function = "predefined.sql",
+    Number = "number.sql",
+    String = "string.sql",
+    Variable = "variable.sql"
+}
+
 declare class LinkedToken {
     type: string;
     value: string;
@@ -164,17 +178,6 @@ declare class LinkedToken {
     getNextOfType(type: TokenType, value?: string): LinkedToken | null;
 }
 
-type StatementPositionResolver = (currentToken: LinkedToken | null, previousKeyword: LinkedToken | null, previousNonWhiteSpace: LinkedToken | null, previousIsSlash: Boolean) => Boolean;
-type SuggestionsResolver = <T extends PositionContext = PositionContext>(positionContext: T) => Promise<CustomSuggestion[]>;
-interface SQLMonarchLanguage extends monacoTypes.languages.IMonarchLanguage {
-    keywords?: string[];
-    builtinFunctions?: string[];
-    logicalOperators?: string[];
-    comparisonOperators?: string[];
-    /** Used by basic languages in the monaco registry **/
-    operators?: string[];
-}
-
 /**
  * Provides a context for suggestions resolver
  * @alpha
@@ -290,7 +293,25 @@ interface SQLCompletionItemProvider extends Omit<monacoTypes.languages.Completio
      */
     provideCompletionItems?: (model: monacoTypes.editor.ITextModel, position: monacoTypes.Position, context: monacoTypes.languages.CompletionContext, token: monacoTypes.CancellationToken, positionContext: PositionContext) => monacoTypes.languages.CompletionList;
 }
+interface SQLMonarchLanguage extends monacoTypes.languages.IMonarchLanguage {
+    keywords?: string[];
+    builtinFunctions?: string[];
+    logicalOperators?: string[];
+    comparisonOperators?: string[];
+    /** Used by basic languages in the monaco registry **/
+    operators?: string[];
+}
+type StatementPositionResolver = (currentToken: LinkedToken | null, previousKeyword: LinkedToken | null, previousNonWhiteSpace: LinkedToken | null, previousIsSlash: Boolean) => Boolean;
+type SuggestionsResolver = <T extends PositionContext = PositionContext>(positionContext: T) => Promise<CustomSuggestion[]>;
 type LanguageCompletionProvider = (m: Monaco, l?: SQLMonarchLanguage) => SQLCompletionItemProvider;
+interface LanguageDefinition extends monacoTypes.languages.ILanguageExtensionPoint {
+    loader?: (module: any) => Promise<{
+        language: SQLMonarchLanguage;
+        conf: monacoTypes.languages.LanguageConfiguration;
+    }>;
+    completionProvider?: (m: Monaco, language: SQLMonarchLanguage) => SQLCompletionItemProvider;
+    formatter?: (q: string) => string;
+}
 declare enum OperatorType {
     Comparison = 0,
     Logical = 1
@@ -302,20 +323,7 @@ declare enum MacroType {
     Column = 3,
     Table = 4
 }
-declare enum TokenType {
-    Parenthesis = "delimiter.parenthesis.sql",
-    Whitespace = "white.sql",
-    Keyword = "keyword.sql",
-    Delimiter = "delimiter.sql",
-    Operator = "operator.sql",
-    Identifier = "identifier.sql",
-    IdentifierQuote = "identifier.quote.sql",
-    Type = "type.sql",
-    Function = "predefined.sql",
-    Number = "number.sql",
-    String = "string.sql",
-    Variable = "variable.sql"
-}
+
 declare enum StatementPosition {
     Unknown = "unknown",
     SelectKeyword = "selectKeyword",
@@ -417,14 +425,6 @@ declare enum SQLEditorMode {
     Code = "code"
 }
 
-interface LanguageDefinition extends monacoTypes.languages.ILanguageExtensionPoint {
-    loader?: (module: any) => Promise<{
-        language: SQLMonarchLanguage;
-        conf: monacoTypes.languages.LanguageConfiguration;
-    }>;
-    completionProvider?: (m: Monaco, language: SQLMonarchLanguage) => SQLCompletionItemProvider;
-    formatter?: (q: string) => string;
-}
 interface SQLEditorProps {
     query: string;
     /**
@@ -640,6 +640,11 @@ interface MetaDefinition {
     completion?: string;
     kind: CompletionItemKind;
 }
+/**
+ * Represents a query with all default values applied.
+ * This is equivalent to SQLQuery since applyQueryDefaults returns SQLQuery.
+ */
+type QueryWithDefaults = SQLQuery;
 
 interface GroupByRowProps {
     sql: SQLExpression;
@@ -781,8 +786,9 @@ interface MetricFindQueryOptions extends SearchFilterOptions {
 }
 
 interface Props$p extends QueryEditorProps$1<SqlDatasource, SQLQuery, SQLOptions> {
+    language?: SqlLanguage;
 }
-declare function SqlQueryEditor({ datasource, query, onChange, onRunQuery, range }: Props$p): React.JSX.Element | null;
+declare function SqlQueryEditor({ datasource, query, onChange, onRunQuery, range, language }: Props$p): React.JSX.Element | null;
 
 type RunQueryButtonProps = {
     ariaLabel?: string;
@@ -1232,4 +1238,61 @@ interface Props {
 }
 declare function RawQuery({ query, language, className }: Props): React.JSX.Element;
 
-export { AccessoryButton, AdvancedHttpSettings, type Aggregate, Auth, AuthMethod, type Props$c as AuthProps, BINARY_OPERATIONS_KEY, CatalogSelector, type ColumnDefinition, CompletionItemInsertTextRule, CompletionItemKind, CompletionItemPriority, ConfigDescriptionLink, ConfigSection, ConfigSubSection, ConnectionSettings, CustomHeadersSettings, type DB, DataLink, type DataLinkConfig, DataLinks, DataSourceDescription, DataSourcePicker, DatasetSelector, DatePicker, type DatePickerProps, DatePickerWithInput, type DatePickerWithInputProps, DebounceInput, type DebounceInputProps, EditorField, EditorFieldGroup, EditorHeader, EditorList, EditorMode, EditorRow, EditorRows, EditorStack, EditorSwitch, FlexItem, GroupByRow, InlineSelect, InputGroup, LabelFilters, type LanguageCompletionProvider, type LanguageDefinition, LinkedToken, MacroType, type MetaDefinition, type NameValue, OperationExplainedBox, OperationList, OperationListExplained, OperationsEditorRow, OperatorType, type PositionContext, type Props$s as Props, QUERY_FORMAT_OPTIONS, QueryBuilderHints, type QueryBuilderLabelFilter, type QueryBuilderOperation, type QueryBuilderOperationDefinition, type QueryBuilderOperationParamDef, type QueryBuilderOperationParamEditorProps, type QueryBuilderOperationParamValue, QueryEditorMode, QueryEditorModeToggle, type QueryEditorProps, QueryEditorRow, QueryFormat, QueryHeaderSwitch, QueryModellerBase, QueryOptionGroup, type QueryRowFilter, type QueryStats, type RAQBFieldTypes, RawQuery, type ResourceSelectorProps, type ResponseParser, RunQueryButton, type SQLConnectionLimits, SQLEditor, SQLEditorMode, SQLEditorTestUtils, type SQLExpression, type SQLFilters, type SQLMonarchLanguage, type SQLOptions, type SQLQuery, type SQLSelectableValue, type SchemaDefinition, SecureSocksProxyToggle, Segment, type SegmentProps, Space, SqlDatasource, SqlQueryEditor, type SqlQueryForInterpolation, type SqlQueryModel, type State$1 as State, type StatementPlacementProvider, StatementPosition, SuggestionKind, type SuggestionKindProvider, TLSSettings, type Props$f as TLSSettingsProps, type TableDefinition, type TableFieldSchema, type TableIdentifier, type TableSchema, TableSelector, type TestQueryModel, TokenType, type ValidationResults, type VisualQuery, type VisualQueryBinary, type VisualQueryModeller, convertLegacyAuthProps, formatDate, getStandardSQLCompletionProvider, language as grafanaStandardSQLLanguage, conf as grafanaStandardSQLLanguageConf, toOption };
+interface CustomMeta {
+    queryID: string;
+    status: string;
+}
+interface RunningQueryInfo {
+    queryID?: string;
+    shouldCancel?: boolean;
+}
+declare class DatasourceWithAsyncBackend<TQuery extends DataQuery$1 = DataQuery$1, TOptions extends DataSourceJsonData = DataSourceJsonData> extends DataSourceWithBackend<TQuery, TOptions> {
+    private runningQueries;
+    private requestCounter;
+    private requestIdPrefix;
+    constructor(instanceSettings: DataSourceInstanceSettings<TOptions>);
+    query(request: DataQueryRequest<TQuery>): Observable<DataQueryResponse>;
+    storeQuery(target: TQuery, queryInfo: RunningQueryInfo): void;
+    getQuery(target: TQuery): RunningQueryInfo;
+    removeQuery(target: TQuery): void;
+    doSingle(target: TQuery, request: DataQueryRequest<TQuery>): Observable<DataQueryResponse>;
+    cancel: (target: TQuery) => void;
+}
+
+interface RunQueryButtonsProps<TQuery extends DataQuery$1> {
+    enableRun?: boolean;
+    onRunQuery: () => void;
+    onCancelQuery: (query: TQuery) => void;
+    query: TQuery;
+    state?: LoadingState;
+}
+declare const RunQueryButtons: <TQuery extends DataQuery$1>(props: RunQueryButtonsProps<TQuery>) => React.JSX.Element;
+
+interface RequestLoopOptions<TQuery extends DataQuery$1 = DataQuery$1> {
+    /**
+     * If the response needs an additional request to execute, return it here
+     */
+    getNextQuery: (rsp: DataQueryResponse) => TQuery | undefined;
+    /**
+     * The datasource execute method
+     */
+    query: (req: DataQueryRequest<TQuery>) => Observable<DataQueryResponse>;
+    /**
+     * Process the results
+     */
+    process: (data: DataFrame[]) => DataFrame[];
+    /**
+     * Check if the query should be cancelled
+     */
+    shouldCancel: () => boolean;
+    /**
+     * Callback that gets executed when unsubscribed
+     */
+    onCancel: () => void;
+}
+/**
+ * Continue executing requests as long as `getNextQuery` returns a query
+ */
+declare function getRequestLooper<T extends DataQuery$1 = DataQuery$1>(req: DataQueryRequest<T>, options: RequestLoopOptions<T>): Observable<DataQueryResponse>;
+
+export { AccessoryButton, AdvancedHttpSettings, type Aggregate, Auth, AuthMethod, type Props$c as AuthProps, BINARY_OPERATIONS_KEY, CatalogSelector, type ColumnDefinition, CompletionItemInsertTextRule, CompletionItemKind, CompletionItemPriority, ConfigDescriptionLink, ConfigSection, ConfigSubSection, ConnectionSettings, CustomHeadersSettings, type CustomMeta, type DB, DataLink, type DataLinkConfig, DataLinks, DataSourceDescription, DataSourcePicker, DatasetSelector, DatasourceWithAsyncBackend, DatePicker, type DatePickerProps, DatePickerWithInput, type DatePickerWithInputProps, DebounceInput, type DebounceInputProps, EditorField, EditorFieldGroup, EditorHeader, EditorList, EditorMode, EditorRow, EditorRows, EditorStack, EditorSwitch, FlexItem, GroupByRow, InlineSelect, InputGroup, LabelFilters, type LanguageCompletionProvider, type LanguageDefinition, LinkedToken, MacroType, type MetaDefinition, type NameValue, OperationExplainedBox, OperationList, OperationListExplained, OperationsEditorRow, OperatorType, type PositionContext, type Props$s as Props, QUERY_FORMAT_OPTIONS, QueryBuilderHints, type QueryBuilderLabelFilter, type QueryBuilderOperation, type QueryBuilderOperationDefinition, type QueryBuilderOperationParamDef, type QueryBuilderOperationParamEditorProps, type QueryBuilderOperationParamValue, QueryEditorMode, QueryEditorModeToggle, type QueryEditorProps, QueryEditorRow, QueryFormat, QueryHeaderSwitch, QueryModellerBase, QueryOptionGroup, type QueryRowFilter, type QueryStats, type QueryWithDefaults, type RAQBFieldTypes, RawQuery, type RequestLoopOptions, type ResourceSelectorProps, type ResponseParser, RunQueryButton, RunQueryButtons, type RunQueryButtonsProps, type RunningQueryInfo, type SQLConnectionLimits, SQLEditor, SQLEditorMode, SQLEditorTestUtils, type SQLExpression, type SQLFilters, type SQLMonarchLanguage, type SQLOptions, type SQLQuery, type SQLSelectableValue, type SchemaDefinition, SecureSocksProxyToggle, Segment, type SegmentProps, Space, SqlDatasource, SqlQueryEditor, type SqlQueryForInterpolation, type SqlQueryModel, type State$1 as State, type StatementPlacementProvider, StatementPosition, SuggestionKind, type SuggestionKindProvider, TLSSettings, type Props$f as TLSSettingsProps, type TableDefinition, type TableFieldSchema, type TableIdentifier, type TableSchema, TableSelector, type TestQueryModel, TokenType, type ValidationResults, type VisualQuery, type VisualQueryBinary, type VisualQueryModeller, convertLegacyAuthProps, formatDate, getRequestLooper, getStandardSQLCompletionProvider, language as grafanaStandardSQLLanguage, conf as grafanaStandardSQLLanguageConf, toOption };

package/dist/esm/index.js

@@ -55,6 +55,10 @@ export { SQLEditorTestUtils } from './components/SQLEditor/test-utils/index.js';
 export { LinkedToken } from './components/SQLEditor/utils/LinkedToken.js';
 export { language as grafanaStandardSQLLanguage, conf as grafanaStandardSQLLanguageConf } from './components/SQLEditor/standardSql/language.js';
 export { getStandardSQLCompletionProvider } from './components/SQLEditor/standardSql/standardSQLCompletionItemProvider.js';
-export { CompletionItemInsertTextRule, CompletionItemKind, CompletionItemPriority, MacroType, OperatorType, SQLEditorMode, StatementPosition, SuggestionKind, TokenType } from './components/SQLEditor/types.js';
+export { CompletionItemInsertTextRule, CompletionItemKind, CompletionItemPriority, MacroType, OperatorType, SQLEditorMode, StatementPosition, SuggestionKind } from './components/SQLEditor/types.js';
+export { DatasourceWithAsyncBackend } from './async-query-data/DatasourceWithAsyncBackend.js';
+export { RunQueryButtons } from './async-query-data/RunQueryButtons.js';
+export { getRequestLooper } from './async-query-data/requestLooper.js';
 export { SqlDatasource } from './datasource/SqlDatasource.js';
+export { TokenType } from './components/SQLEditor/utils/tokenType.js';
 //# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}