@kusto/monaco-kusto 7.0.0 → 7.2.0

package/release/esm/schema-53127847.js

@@ -0,0 +1,85 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * monaco-kusto version: 7.2.0(ff25adc61b13954e5ec288fcdc16c92483943ef5)
+ * Released under the MIT license
+ * https://https://github.com/Azure/monaco-kusto/blob/master/README.md
+ *-----------------------------------------------------------------------------*/
+
+// Definition of schema object in the context of language services. This model is exposed to consumers of this library.
+
+/**
+ * An input parameter either be a scalar in which case it has a name, type and
+ * cslType, or it can be columnar, in which case it will have a name, and a list
+ * of scalar types which are the column types.
+ */
+
+/**
+ * Schema types:
+ * Engine – The main schema type. Contains clusters, databases, tables, table columns and functions.
+ * Cluster Manager – Internal only. A schema for clusters that manages other clusters.
+ * Data Management – Internal only. A schema for ingestion point operations.
+ */
+
+const dotnetTypeToKustoType = {
+  'System.SByte': 'bool',
+  'System.Byte': 'uint8',
+  'System.Int16': 'int16',
+  'System.UInt16': 'uint16',
+  'System.Int32': 'int',
+  'System.UInt32': 'uint',
+  'System.Int64': 'long',
+  'System.UInt64': 'ulong',
+  'System.String': 'string',
+  'System.Single': 'float',
+  'System.Double': 'real',
+  'System.DateTime': 'datetime',
+  'System.TimeSpan': 'timespan',
+  'System.Guid': 'guid',
+  'System.Boolean': 'bool',
+  'Newtonsoft.Json.Linq.JArray': 'dynamic',
+  'Newtonsoft.Json.Linq.JObject': 'dynamic',
+  'Newtonsoft.Json.Linq.JToken': 'dynamic',
+  'System.Object': 'dynamic',
+  'System.Data.SqlTypes.SqlDecimal': 'decimal'
+};
+const getCslTypeNameFromClrType = clrType => dotnetTypeToKustoType[clrType] || clrType;
+const kustoTypeToEntityDataType = {
+  object: 'Object',
+  bool: 'Boolean',
+  uint8: 'Byte',
+  int16: 'Int16',
+  uint16: 'UInt16',
+  int: 'Int32',
+  uint: 'UInt32',
+  long: 'Int64',
+  ulong: 'UInt64',
+  float: 'Single',
+  real: 'Double',
+  decimal: 'Decimal',
+  datetime: 'DateTime',
+  string: 'String',
+  dynamic: 'Dynamic',
+  timespan: 'TimeSpan'
+};
+const getEntityDataTypeFromCslType = cslType => kustoTypeToEntityDataType[cslType] || cslType;
+const getCallName = fn => `${fn.name}(${fn.inputParameters.map(p => `{${p.name}}`).join(',')})`;
+const getExpression = fn => `let ${fn.name} = ${getInputParametersAsCslString(fn.inputParameters)} ${fn.body}`;
+const getInputParametersAsCslString = inputParameters => `(${inputParameters.map(inputParameter => getInputParameterAsCslString(inputParameter)).join(',')})`;
+const getInputParameterAsCslString = inputParameter => {
+  // If this is a tabular parameter
+  if (inputParameter.columns && inputParameter.columns.length > 0) {
+    const attributesAsString = inputParameter.columns.map(col => `${col.name}:${col.cslType || getCslTypeNameFromClrType(col.type)}`).join(',');
+    return `${inputParameter.name}:${attributesAsString === '' ? '*' : attributesAsString}`;
+  } else {
+    return `${inputParameter.name}:${inputParameter.cslType || getCslTypeNameFromClrType(inputParameter.type)}`;
+  }
+};
+
+/**
+ * This is the schema of the output of kusto command
+ * .show schema as json
+ */
+let showSchema;
+(function (_showSchema) {})(showSchema || (showSchema = {}));
+
+export { getCallName as a, getExpression as b, getInputParametersAsCslString as c, getEntityDataTypeFromCslType as d, getCslTypeNameFromClrType as g, showSchema as s };

package/release/esm/types.d.ts

@@ -1,34 +1,8 @@
 import type * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
 import type * as ls from 'vscode-languageserver-types';
-export interface LanguageSettings {
-    includeControlCommands?: boolean;
-    newlineAfterPipe?: boolean;
-    syntaxErrorAsMarkDown?: SyntaxErrorAsMarkDownOptions;
-    openSuggestionDialogAfterPreviousSuggestionAccepted?: boolean;
-    useIntellisenseV2?: boolean;
-    useSemanticColorization?: boolean;
-    useTokenColorization?: boolean;
-    disabledCompletionItems?: string[];
-    onDidProvideCompletionItems?: OnDidProvideCompletionItems;
-    enableHover?: boolean;
-    formatter?: FormatterOptions;
-    enableQueryWarnings?: boolean;
-    enableQuerySuggestions?: boolean;
-    disabledDiagnosticCodes?: string[];
-    quickFixCodeActions?: QuickFixCodeActionOptions[];
-    enableQuickFixes?: boolean;
-}
-export interface SyntaxErrorAsMarkDownOptions {
-    header?: string;
-    icon?: string;
-    enableSyntaxErrorAsMarkDown?: boolean;
-}
-export type QuickFixCodeActionOptions = 'Extract Expression' | 'Extract Function' | 'Change to' | 'FixAll';
-export interface FormatterOptions {
-    indentationSize?: number;
-    pipeOperatorStyle?: FormatterPlacementStyle;
-}
-export type FormatterPlacementStyle = 'None' | 'NewLine' | 'Smart';
+import type { Schema, ScalarParameter, TabularParameter, EngineSchema, Database, showSchema } from './languageService/schema';
+import type { RenderInfo } from './languageService/renderInfo';
+import type { LanguageSettings } from './languageService/settings';
 export interface LanguageServiceDefaults {
     readonly onDidChange: monaco.IEvent<LanguageServiceDefaults>;
     readonly languageSettings: LanguageSettings;
@@ -47,8 +21,8 @@ export interface LanguageServiceDefaults {
 }
 export interface KustoWorker {
     setSchema(schema: Schema): Promise<void>;
-    setSchemaFromShowSchema(schema: any, clusterConnectionString: string, databaseInContextName: string, globalScalarParameters: ScalarParameter[], globalTabularParameters: TabularParameter[]): Promise<void>;
-    normalizeSchema(schema: any, clusterConnectionString: string, databaseInContextName: string): Promise<EngineSchema>;
+    setSchemaFromShowSchema(schema: any, clusterConnectionString: string, databaseInContextName: string, globalScalarParameters?: ScalarParameter[], globalTabularParameters?: TabularParameter[]): Promise<void>;
+    normalizeSchema(schema: showSchema.Result, clusterConnectionString: string, databaseInContextName: string): Promise<EngineSchema>;
     getCommandInContext(uri: string, cursorOffset: number): Promise<string | null>;
     getCommandAndLocationInContext(uri: string, offset: number): Promise<{
         text: string;
@@ -88,7 +62,7 @@ export interface KustoWorker {
     }[]>;
     /**
      * Get the global parameters that are actually being referenced in query.
-     * This is different from getQueryParams that will return the parameters declare using a query declaration
+     * This is different from getQueryParams that will return the parameters using a query declaration
      * statement.
      * It is also different from getGlobalParams that will return all global parameters whether used or not.
      */
@@ -96,7 +70,7 @@ export interface KustoWorker {
         name: string;
         type: string;
     }[]>;
-    getReferencedSymbols(document: ls.TextDocument, cursorOffset?: number): Promise<{
+    getReferencedSymbols(uri: string, cursorOffset?: number): Promise<{
         name: string;
         kind: string;
         display: string;
@@ -112,7 +86,7 @@ export interface KustoWorker {
         start: number;
         end: number;
     }[], includeWarnings?: boolean, includeSuggestions?: boolean): Promise<ls.Diagnostic[]>;
-    setParameters(scalarParameters: readonly ScalarParameter[], tabularParameters: readonly TabularParameter[]): void;
+    setParameters(scalarParameters: readonly ScalarParameter[], tabularParameters: readonly TabularParameter[]): Promise<void>;
     /**
      * Get all the database references from the current command.
      * If database's schema is already cached in previous calls to setSchema or addDatabaseToSchema it will not be returned.
@@ -165,91 +139,6 @@ export interface KustoWorker {
 export interface WorkerAccessor {
     (first: monaco.Uri, ...more: monaco.Uri[]): Promise<KustoWorker>;
 }
-export interface Column {
-    name: string;
-    type: string;
-    docstring?: string;
-}
-export interface Table {
-    name: string;
-    columns: Column[];
-    docstring?: string;
-}
-export interface ScalarParameter {
-    name: string;
-    type?: string;
-    cslType?: string;
-    cslDefaultValue?: string;
-}
-export interface TabularParameter {
-    name: string;
-    columns: Column[];
-    docstring?: string;
-}
-export type InputParameter = ScalarParameter & {
-    columns?: ScalarParameter[];
-};
-export interface Function {
-    name: string;
-    body: string;
-    docstring?: string;
-    inputParameters: InputParameter[];
-}
-export interface Database {
-    name: string;
-    tables: Table[];
-    functions: Function[];
-    majorVersion: number;
-    minorVersion: number;
-}
-export interface EngineSchema {
-    clusterType: 'Engine';
-    cluster: {
-        connectionString: string;
-        databases: Database[];
-    };
-    database: Database | undefined;
-}
-export interface ClusterMangerSchema {
-    clusterType: 'ClusterManager';
-    accounts: string[];
-    services: string[];
-    connectionString: string;
-}
-export interface DataManagementSchema {
-    clusterType: 'DataManagement';
-}
-export type Schema = EngineSchema | ClusterMangerSchema | DataManagementSchema;
-export declare type VisualizationType = 'anomalychart' | 'areachart' | 'barchart' | 'columnchart' | 'ladderchart' | 'linechart' | 'piechart' | 'pivotchart' | 'scatterchart' | 'stackedareachart' | 'timechart' | 'table' | 'timeline' | 'timepivot' | 'card';
-export declare type Scale = 'linear' | 'log';
-export declare type LegendVisibility = 'visible' | 'hidden';
-export declare type YSplit = 'none' | 'axes' | 'panels';
-export declare type Kind = 'default' | 'unstacked' | 'stacked' | 'stacked100' | 'map';
-export interface RenderOptions {
-    visualization?: null | VisualizationType;
-    title?: null | string;
-    xcolumn?: null | string;
-    series?: null | string[];
-    ycolumns?: null | string[];
-    xtitle?: null | string;
-    ytitle?: null | string;
-    xaxis?: null | Scale;
-    yaxis?: null | Scale;
-    legend?: null | LegendVisibility;
-    ySplit?: null | YSplit;
-    accumulate?: null | boolean;
-    kind?: null | Kind;
-    anomalycolumns?: null | string[];
-    ymin?: null | number;
-    ymax?: null | number;
-}
-export interface RenderInfo {
-    options: RenderOptions;
-    location: {
-        startOffset: number;
-        endOffset: number;
-    };
-}
 export interface DatabaseReference {
     databaseName: string;
     clusterName: string;
@@ -257,5 +146,4 @@ export interface DatabaseReference {
 export interface ClusterReference {
     clusterName: string;
 }
-export type RenderOptionKeys = keyof RenderOptions;
 export type OnDidProvideCompletionItems = (list: ls.CompletionList) => Promise<ls.CompletionList>;

package/release/esm/workerManager.d.ts

@@ -1,6 +1,6 @@
 import type * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
 import type { LanguageServiceDefaults } from './monaco.contribution';
-import type { KustoWorker } from './kustoWorker';
+import type { IKustoWorkerImpl } from './kustoWorker';
 export declare class WorkerManager {
     private _monacoInstance;
     private _storedState;
@@ -16,5 +16,5 @@ export declare class WorkerManager {
     dispose(): void;
     private _checkIfIdle;
     private _getClient;
-    getLanguageServiceWorker(...resources: monaco.Uri[]): Promise<KustoWorker>;
+    getLanguageServiceWorker(...resources: monaco.Uri[]): Promise<IKustoWorkerImpl>;
 }