@grafana/sql 0.0.0 → 13.0.0-23483592685

package/dist/types/datasource/SqlDatasource.d.ts

@@ -0,0 +1,38 @@
+import { Observable } from 'rxjs';
+import { DataFrameView, DataQueryRequest, DataQueryResponse, DataSourceInstanceSettings, MetricFindValue, ScopedVars, LegacyMetricFindQueryOptions, VariableWithMultiSupport } from '@grafana/data';
+import { DataSourceWithBackend, TemplateSrv } from '@grafana/runtime';
+import { ResponseParser } from '../ResponseParser';
+import { DB, SQLQuery, SQLOptions, SqlQueryModel, QueryFormat, SQLDialect } from '../types';
+export declare abstract class SqlDatasource extends DataSourceWithBackend<SQLQuery, SQLOptions> {
+    protected readonly templateSrv: TemplateSrv;
+    uid: string;
+    responseParser: ResponseParser;
+    name: string;
+    interval: string;
+    db: DB;
+    preconfiguredDatabase: string;
+    dialect: SQLDialect;
+    constructor(instanceSettings: DataSourceInstanceSettings<SQLOptions>, templateSrv?: TemplateSrv);
+    abstract getDB(): DB;
+    abstract getQueryModel(target?: SQLQuery, templateSrv?: TemplateSrv, scopedVars?: ScopedVars): SqlQueryModel;
+    getResponseParser(): ResponseParser;
+    interpolateVariable: (value: string | string[] | number, variable: VariableWithMultiSupport) => string | number;
+    interpolateVariablesInQueries(queries: SQLQuery[], scopedVars: ScopedVars): SQLQuery[];
+    filterQuery(query: SQLQuery): boolean;
+    applyTemplateVariables(target: SQLQuery, scopedVars: ScopedVars): {
+        refId: string;
+        datasource: import("@grafana/schema").DataSourceRef;
+        rawSql: string;
+        format: QueryFormat | undefined;
+    };
+    query(request: DataQueryRequest<SQLQuery>): Observable<DataQueryResponse>;
+    private checkForDatabaseIssue;
+    metricFindQuery(query: string, options?: LegacyMetricFindQueryOptions): Promise<MetricFindValue[]>;
+    runSql<T extends object>(query: string, options?: RunSQLOptions): Promise<DataFrameView<T>>;
+    private runMetaQuery;
+    targetContainsTemplate(target: SQLQuery): boolean;
+}
+interface RunSQLOptions extends LegacyMetricFindQueryOptions {
+    refId?: string;
+}
+export {};

package/dist/types/defaults.d.ts

@@ -0,0 +1,3 @@
+import { SQLQuery } from './types';
+export declare function applyQueryDefaults(q?: SQLQuery): SQLQuery;
+export type QueryWithDefaults = ReturnType<typeof applyQueryDefaults>;

package/dist/types/expressions.d.ts

@@ -0,0 +1,51 @@
+export declare enum QueryEditorPropertyType {
+    String = "string"
+}
+export interface QueryEditorProperty {
+    type: QueryEditorPropertyType;
+    name?: string;
+}
+export type QueryEditorOperatorType = string | boolean | number;
+type QueryEditorOperatorValueType = QueryEditorOperatorType | QueryEditorOperatorType[];
+export interface QueryEditorOperator<T extends QueryEditorOperatorValueType> {
+    name?: string;
+    value?: T;
+}
+export interface QueryEditorOperatorExpression {
+    type: QueryEditorExpressionType.Operator;
+    property: QueryEditorProperty;
+    operator: QueryEditorOperator<QueryEditorOperatorValueType>;
+}
+export interface QueryEditorArrayExpression {
+    type: QueryEditorExpressionType.And | QueryEditorExpressionType.Or;
+    expressions: QueryEditorExpression[] | QueryEditorArrayExpression[];
+}
+export interface QueryEditorPropertyExpression {
+    type: QueryEditorExpressionType.Property;
+    property: QueryEditorProperty;
+}
+export declare enum QueryEditorExpressionType {
+    Property = "property",
+    Operator = "operator",
+    Or = "or",
+    And = "and",
+    GroupBy = "groupBy",
+    Function = "function",
+    FunctionParameter = "functionParameter"
+}
+export type QueryEditorExpression = QueryEditorArrayExpression | QueryEditorPropertyExpression | QueryEditorGroupByExpression | QueryEditorFunctionExpression | QueryEditorFunctionParameterExpression | QueryEditorOperatorExpression;
+export interface QueryEditorGroupByExpression {
+    type: QueryEditorExpressionType.GroupBy;
+    property: QueryEditorProperty;
+}
+export interface QueryEditorFunctionExpression {
+    type: QueryEditorExpressionType.Function;
+    name?: string;
+    alias?: string;
+    parameters?: QueryEditorFunctionParameterExpression[];
+}
+export interface QueryEditorFunctionParameterExpression {
+    type: QueryEditorExpressionType.FunctionParameter;
+    name?: string;
+}
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,21 @@
+export type { DB, RAQBFieldTypes, SQLExpression, SQLOptions, SQLQuery, SqlQueryModel, SQLSelectableValue, SQLDialect, Func, FuncParameter, } from './types';
+export { QueryFormat } from './types';
+export { COMMON_FNS, MACRO_FUNCTIONS } from './constants';
+export { SqlDatasource } from './datasource/SqlDatasource';
+export { formatSQL } from './utils/formatSQL';
+export { ConnectionLimits } from './components/configuration/ConnectionLimits';
+export { MaxLifetimeField } from './components/configuration/MaxLifetimeField';
+export { MaxOpenConnectionsField } from './components/configuration/MaxOpenConnectionsField';
+export { NumberInput } from './components/configuration/NumberInput';
+export { Divider } from './components/configuration/Divider';
+export { TLSSecretsConfig } from './components/configuration/TLSSecretsConfig';
+export { useMigrateDatabaseFields } from './components/configuration/useMigrateDatabaseFields';
+export { Preview } from './components/visual-query-builder/Preview';
+export { SqlQueryEditorLazy } from './components/QueryEditorLazy';
+export type { QueryHeaderProps } from './components/QueryHeader';
+export { SQLVariableSupport } from './SQLVariableSupport';
+export { createSelectClause, haveColumns } from './utils/sql.utils';
+export { applyQueryDefaults } from './defaults';
+export { makeVariable } from './utils/testHelpers';
+export { QueryEditorExpressionType } from './expressions';
+export { loadResources } from './loadResources';

package/dist/types/loadResources.d.ts

@@ -0,0 +1,2 @@
+import { ResourceLoader } from '@grafana/i18n';
+export declare const loadResources: ResourceLoader;

package/dist/types/types.d.ts

@@ -0,0 +1,152 @@
+import { JsonTree } from '@react-awesome-query-builder/ui';
+import { DataFrame, DataQuery, DataSourceJsonData, MetricFindValue, SelectableValue, TimeRange } from '@grafana/data';
+import { CompletionItemKind, EditorMode, LanguageDefinition } from '@grafana/plugin-ui';
+import { QueryWithDefaults } from './defaults';
+import { QueryEditorFunctionExpression, QueryEditorGroupByExpression, QueryEditorPropertyExpression } from './expressions';
+export interface SqlQueryForInterpolation {
+    dataset?: string;
+    alias?: string;
+    format?: QueryFormat;
+    rawSql?: string;
+    refId: string;
+    hide?: boolean;
+}
+export interface SQLConnectionLimits {
+    maxOpenConns: number;
+    maxIdleConns: number;
+    maxIdleConnsAuto: boolean;
+    connMaxLifetime: number;
+}
+export interface SQLOptions extends SQLConnectionLimits, DataSourceJsonData {
+    tlsAuth: boolean;
+    tlsAuthWithCACert: boolean;
+    timezone: string;
+    tlsSkipVerify: boolean;
+    user: string;
+    database: string;
+    url: string;
+    timeInterval: string;
+}
+export declare enum QueryFormat {
+    Timeseries = "time_series",
+    Table = "table"
+}
+export type SQLQueryMeta = {
+    valueField?: string;
+    textField?: string;
+};
+export interface SQLQuery extends DataQuery {
+    alias?: string;
+    format?: QueryFormat;
+    rawSql?: string;
+    dataset?: string;
+    table?: string;
+    sql?: SQLExpression;
+    editorMode?: EditorMode;
+    rawQuery?: boolean;
+    meta?: SQLQueryMeta;
+}
+export type SQLVariableQuery = {
+    query: string;
+} & SQLQuery;
+export interface NameValue {
+    name: string;
+    value: string;
+}
+export type SQLFilters = NameValue[];
+export interface SQLExpression {
+    columns?: QueryEditorFunctionExpression[];
+    whereJsonTree?: JsonTree;
+    whereString?: string;
+    filters?: SQLFilters;
+    groupBy?: QueryEditorGroupByExpression[];
+    orderBy?: QueryEditorPropertyExpression;
+    orderByDirection?: 'ASC' | 'DESC';
+    limit?: number;
+    offset?: number;
+}
+export interface TableSchema {
+    name?: string;
+    schema?: TableFieldSchema[];
+}
+export interface TableFieldSchema {
+    name: string;
+    description?: string;
+    type: string;
+    repeated: boolean;
+    schema: TableFieldSchema[];
+}
+export interface QueryRowFilter {
+    filter: boolean;
+    group: boolean;
+    order: boolean;
+    preview: boolean;
+}
+export declare const QUERY_FORMAT_OPTIONS: {
+    label: string;
+    value: QueryFormat;
+}[];
+export declare const toOption: (value: string) => SelectableValue<string>;
+export interface ResourceSelectorProps {
+    disabled?: boolean;
+    className?: string;
+    applyDefault?: boolean;
+}
+export type RAQBFieldTypes = 'text' | 'number' | 'boolean' | 'datetime' | 'date' | 'time';
+export interface SQLSelectableValue extends SelectableValue {
+    type?: string;
+    raqbFieldType?: RAQBFieldTypes;
+}
+export interface DB {
+    init?: (datasourceId?: string) => Promise<boolean>;
+    datasets: () => Promise<string[]>;
+    tables: (dataset?: string) => Promise<string[]>;
+    fields: (query: SQLQuery, order?: boolean) => Promise<SQLSelectableValue[]>;
+    validateQuery: (query: SQLQuery, range?: TimeRange) => Promise<ValidationResults>;
+    dispose?: (dsID?: string) => void;
+    lookup?: (path?: string) => Promise<Array<{
+        name: string;
+        completion: string;
+    }>>;
+    getEditorLanguageDefinition: () => LanguageDefinition;
+    toRawSql: (query: SQLQuery) => string;
+    functions: () => Func[];
+}
+export interface FuncParameter {
+    name: string;
+    required?: boolean;
+    options?: (query: SQLQuery) => Promise<SelectableValue[]>;
+}
+export interface Func {
+    name: string;
+    parameters?: FuncParameter[];
+    description?: string;
+}
+export interface QueryEditorProps {
+    db: DB;
+    query: QueryWithDefaults;
+    onChange: (query: SQLQuery) => void;
+    range?: TimeRange;
+}
+export interface ValidationResults {
+    query: SQLQuery;
+    rawSql?: string;
+    error: string;
+    isError: boolean;
+    isValid: boolean;
+    statistics?: {
+        TotalBytesProcessed: number;
+    } | null;
+}
+export interface SqlQueryModel {
+    quoteLiteral: (v: string) => string;
+}
+export interface ResponseParser {
+    transformMetricFindResponse: (frame: DataFrame) => MetricFindValue[];
+}
+export interface MetaDefinition {
+    name: string;
+    completion?: string;
+    kind: CompletionItemKind;
+}
+export type SQLDialect = 'postgres' | 'influx' | 'other';

package/dist/types/utils/formatSQL.d.ts

@@ -0,0 +1 @@
+export declare function formatSQL(q: string): any;

package/dist/types/utils/getColumnsWithIndices.d.ts

@@ -0,0 +1,3 @@
+import { SelectableValue } from '@grafana/data';
+import { SQLQuery } from '../types';
+export declare function getColumnsWithIndices(query: SQLQuery, fields: SelectableValue[]): SelectableValue[];

package/dist/types/utils/logging.d.ts

@@ -0,0 +1,2 @@
+import { MonitoringLogger } from '@grafana/runtime';
+export declare const sqlPluginLogger: MonitoringLogger;

package/dist/types/utils/migration.d.ts

@@ -0,0 +1,3 @@
+import { AnnotationQuery } from '@grafana/data';
+import { SQLQuery } from '../types';
+export default function migrateAnnotation(annotation: AnnotationQuery<SQLQuery>): AnnotationQuery<SQLQuery>;

package/dist/types/utils/sql.utils.d.ts

@@ -0,0 +1,21 @@
+import { SelectableValue } from '@grafana/data';
+import { QueryEditorFunctionExpression, QueryEditorFunctionParameterExpression, QueryEditorGroupByExpression, QueryEditorPropertyExpression } from '../expressions';
+import { SQLExpression } from '../types';
+export declare function createSelectClause(sqlColumns: NonNullable<SQLExpression['columns']>): string;
+export declare const haveColumns: (columns: SQLExpression["columns"]) => columns is NonNullable<SQLExpression["columns"]>;
+/**
+ * Creates a GroupByExpression for a specified field
+ */
+export declare function setGroupByField(field?: string): QueryEditorGroupByExpression;
+/**
+ * Creates a PropertyExpression for a specified field
+ */
+export declare function setPropertyField(field?: string): QueryEditorPropertyExpression;
+export declare function createFunctionField(functionName?: string): QueryEditorFunctionExpression;
+/**
+ * Retrieves the column value from a QueryEditorFunctionParameterExpression object.
+ *
+ * @param column - The QueryEditorFunctionParameterExpression object representing the column.
+ * @returns The column value as a SelectableValue<string> or null if the column is undefined or null.
+ */
+export declare function getColumnValue(column?: QueryEditorFunctionParameterExpression | QueryEditorFunctionExpression): SelectableValue<string> | null;

package/dist/types/utils/testHelpers.d.ts

@@ -0,0 +1,2 @@
+import { CustomVariableModel } from '@grafana/data';
+export declare function makeVariable(id: string, name: string, attributes?: Partial<CustomVariableModel>): CustomVariableModel;

package/dist/types/utils/useSqlChange.d.ts

@@ -0,0 +1,10 @@
+import { DB, SQLExpression, SQLQuery } from '../types';
+interface UseSqlChange {
+    db: DB;
+    query: SQLQuery;
+    onQueryChange: (query: SQLQuery) => void;
+}
+export declare function useSqlChange({ query, onQueryChange, db }: UseSqlChange): {
+    onSqlChange: (sql: SQLExpression) => void;
+};
+export {};

package/package.json

@@ -1,15 +1,91 @@
 {
-  "name": "@grafana/sql",
-  "version": "0.0.0",
-  "description": "Shared UI components and utilities used by SQL-based datasource plugins",
   "author": "Grafana Labs",
   "license": "AGPL-3.0-only",
+  "name": "@grafana/sql",
+  "version": "13.0.0-23483592685",
+  "description": "Shared UI components and utilities used by SQL-based datasource plugins",
+  "sideEffects": false,
   "repository": {
     "type": "git",
     "url": "https://github.com/grafana/grafana.git",
     "directory": "packages/grafana-sql"
   },
+  "main": "./dist/cjs/index.cjs",
+  "module": "./dist/esm/index.mjs",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "@grafana-app/source": "./src/index.ts",
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/esm/index.mjs",
+      "require": "./dist/cjs/index.cjs"
+    }
+  },
+  "files": [
+    "./dist",
+    "./README.md",
+    "./CHANGELOG.md",
+    "./LICENSE_AGPL"
+  ],
   "publishConfig": {
     "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p ./tsconfig.build.json && rollup -c rollup.config.ts --configPlugin esbuild",
+    "bundle": "rollup -c rollup.config.ts --configPlugin esbuild",
+    "clean": "rimraf ./dist ./compiled ./package.tgz",
+    "typecheck": "tsc --emitDeclarationOnly false --noEmit",
+    "i18n-extract": "i18next-cli extract --sync-primary",
+    "prepack": "cp package.json package.json.bak && node ../../scripts/prepare-npm-package.js",
+    "postpack": "mv package.json.bak package.json"
+  },
+  "dependencies": {
+    "@emotion/css": "11.13.5",
+    "@grafana/data": ">=10.4.0",
+    "@grafana/e2e-selectors": "13.0.0-23483592685",
+    "@grafana/i18n": "13.0.0-23483592685",
+    "@grafana/plugin-ui": "0.13.1",
+    "@grafana/ui": ">=10.4.0",
+    "@react-awesome-query-builder/ui": "6.6.15",
+    "immutable": "5.1.5",
+    "lodash": "4.17.23",
+    "react-select": "5.10.2",
+    "react-use": "17.6.0",
+    "react-virtualized-auto-sizer": "1.0.26",
+    "rxjs": "7.8.2",
+    "sql-formatter-plus": "1.3.6",
+    "tslib": "2.8.1",
+    "uuid": "11.1.0"
+  },
+  "devDependencies": {
+    "@rollup/plugin-dynamic-import-vars": "2.1.5",
+    "@rollup/plugin-image": "3.0.3",
+    "@rollup/plugin-json": "6.1.0",
+    "@testing-library/dom": "10.4.1",
+    "@testing-library/jest-dom": "^6.1.2",
+    "@testing-library/react": "16.3.0",
+    "@testing-library/user-event": "14.6.1",
+    "@types/jest": "^29.5.4",
+    "@types/lodash": "4.17.20",
+    "@types/node": "24.10.1",
+    "@types/react": "18.3.18",
+    "@types/react-dom": "18.3.5",
+    "@types/react-virtualized-auto-sizer": "1.0.8",
+    "@types/systemjs": "6.15.3",
+    "@types/uuid": "10.0.0",
+    "i18next-cli": "^1.48.0",
+    "jest": "^29.6.4",
+    "rollup": "4.59.0",
+    "ts-jest": "29.4.0",
+    "ts-node": "10.9.2",
+    "typescript": "5.9.2"
+  },
+  "peerDependencies": {
+    "@grafana/data": ">=10.4.0",
+    "@grafana/runtime": ">=10.4.0",
+    "@grafana/ui": ">=10.4.0",
+    "react": "^18.0.0",
+    "react-dom": "^18.0.0"
   }
-}
+}