You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@streampipes.apache.org by oe...@apache.org on 2026/04/01 14:15:24 UTC

(streampipes) branch 4289-improve-convenience-for-event-transformation-scripts updated: Add autocompletion

This is an automated email from the ASF dual-hosted git repository.

oehler pushed a commit to branch 4289-improve-convenience-for-event-transformation-scripts
in repository https://gitbox.apache.org/repos/asf/streampipes.git


The following commit(s) were added to refs/heads/4289-improve-convenience-for-event-transformation-scripts by this push:
     new 93831d534e Add autocompletion
93831d534e is described below

commit 93831d534ea0afe2bf12d1b11ad7aa76089153c7
Author: Sven Oehler <oe...@web.de>
AuthorDate: Wed Apr 1 16:15:08 2026 +0200

    Add autocompletion
---
 .../adapter-script-editor.component.ts             |  50 ++---
 .../static-code-input.component.ts                 |  64 +++----
 .../app/services/javascript-editor-completion.ts   | 203 +++++++++++++++++++++
 3 files changed, 248 insertions(+), 69 deletions(-)

diff --git a/ui/src/app/connect/components/adapter-configuration/configure-schema/script-editor/adapter-script-editor.component.ts b/ui/src/app/connect/components/adapter-configuration/configure-schema/script-editor/adapter-script-editor.component.ts
index 6f93edb9bd..97173c7ec8 100644
--- a/ui/src/app/connect/components/adapter-configuration/configure-schema/script-editor/adapter-script-editor.component.ts
+++ b/ui/src/app/connect/components/adapter-configuration/configure-schema/script-editor/adapter-script-editor.component.ts
@@ -37,6 +37,10 @@ import { MatTooltip } from '@angular/material/tooltip';
 import { TitleCasePipe } from '@angular/common';
 import { TranslatePipe } from '@ngx-translate/core';
 import type * as monacoType from 'monaco-editor';
+import {
+    JavaScriptEventField,
+    registerJavaScriptCompletionProvider,
+} from '../../../../../services/javascript-editor-completion';
 
 declare const monaco: typeof monacoType;
 
@@ -70,6 +74,7 @@ export class AdapterScriptEditorComponent implements OnDestroy {
     loadingAvailableScriptsError = input<any>();
     script = input('');
     eventPropertyNames = input<string[]>([]);
+    eventFields = input<JavaScriptEventField[]>([]);
     editorOptions = input<any>();
     private completionProvider?: monacoType.IDisposable;
 
@@ -91,39 +96,18 @@ export class AdapterScriptEditorComponent implements OnDestroy {
 
     private registerEventPropertyCompletionProvider() {
         this.completionProvider?.dispose();
-        this.completionProvider =
-            monaco.languages.registerCompletionItemProvider('javascript', {
-                triggerCharacters: ['.'],
-                provideCompletionItems: (model, position) => {
-                    const linePrefix = model.getValueInRange({
-                        startLineNumber: position.lineNumber,
-                        startColumn: 1,
-                        endLineNumber: position.lineNumber,
-                        endColumn: position.column,
-                    });
-                    const match = linePrefix.match(/(?:^|[^\w$])event\.(\w*)$/);
-                    if (!match) {
-                        return { suggestions: [] };
-                    }
-
-                    const word = model.getWordUntilPosition(position);
-                    const range = {
-                        startLineNumber: position.lineNumber,
-                        endLineNumber: position.lineNumber,
-                        startColumn: word.startColumn,
-                        endColumn: word.endColumn,
-                    };
-
-                    const suggestions: monacoType.languages.CompletionItem[] =
-                        this.eventPropertyNames().map(runtimeName => ({
-                            label: runtimeName,
-                            kind: monaco.languages.CompletionItemKind.Property,
-                            insertText: runtimeName,
-                            range,
-                        }));
+        this.completionProvider = registerJavaScriptCompletionProvider(
+            monaco,
+            () => {
+                const eventFields = this.eventFields();
+                if (eventFields.length > 0) {
+                    return eventFields;
+                }
 
-                    return { suggestions };
-                },
-            });
+                return this.eventPropertyNames().map(runtimeName => ({
+                    runtimeName,
+                }));
+            },
+        );
     }
 }
diff --git a/ui/src/app/core-ui/static-properties/static-code-input/static-code-input.component.ts b/ui/src/app/core-ui/static-properties/static-code-input/static-code-input.component.ts
index 9060a5c2e3..7657fe25ed 100644
--- a/ui/src/app/core-ui/static-properties/static-code-input/static-code-input.component.ts
+++ b/ui/src/app/core-ui/static-properties/static-code-input/static-code-input.component.ts
@@ -30,6 +30,10 @@ import { MatButton } from '@angular/material/button';
 import { MonacoEditorModule } from 'ngx-monaco-editor-v2';
 import { FormsModule } from '@angular/forms';
 import { TranslatePipe } from '@ngx-translate/core';
+import {
+    JavaScriptEventField,
+    registerJavaScriptCompletionProvider,
+} from '../../../services/javascript-editor-completion';
 
 declare const monaco: typeof monacoType;
 
@@ -109,41 +113,29 @@ export class StaticCodeInputComponent
             return;
         }
         this.completionProvider?.dispose();
-        this.completionProvider =
-            monaco.languages.registerCompletionItemProvider('javascript', {
-                triggerCharacters: ['.'],
-                provideCompletionItems: (model, position) => {
-                    const linePrefix = model.getValueInRange({
-                        startLineNumber: position.lineNumber,
-                        startColumn: 1,
-                        endLineNumber: position.lineNumber,
-                        endColumn: position.column,
-                    });
-                    const match = linePrefix.match(/(?:^|[^\w$])event\.(\w*)$/);
-                    if (!match) {
-                        return { suggestions: [] };
-                    }
-
-                    const word = model.getWordUntilPosition(position);
-                    const range = {
-                        startLineNumber: position.lineNumber,
-                        endLineNumber: position.lineNumber,
-                        startColumn: word.startColumn,
-                        endColumn: word.endColumn,
-                    };
-
-                    const eventProperties =
-                        this.eventSchemas?.[0]?.eventProperties ?? [];
-                    const suggestions: monacoType.languages.CompletionItem[] =
-                        eventProperties.map(ep => ({
-                            label: ep.runtimeName,
-                            kind: monaco.languages.CompletionItemKind.Property,
-                            insertText: ep.runtimeName,
-                            range,
-                        }));
-
-                    return { suggestions };
-                },
-            });
+        this.completionProvider = registerJavaScriptCompletionProvider(
+            monaco,
+            () =>
+                (
+                    (this.eventSchemas?.[0]?.eventProperties ?? []) as {
+                        runtimeName?: string;
+                        propertyScope?: string;
+                        semanticType?: string;
+                    }[]
+                )
+                    .filter(
+                        (
+                            ep,
+                        ): ep is Required<
+                            Pick<JavaScriptEventField, 'runtimeName'>
+                        > &
+                            JavaScriptEventField => !!ep.runtimeName,
+                    )
+                    .map(ep => ({
+                        runtimeName: ep.runtimeName,
+                        propertyScope: ep.propertyScope,
+                        semanticType: ep.semanticType,
+                    })),
+        );
     }
 }
diff --git a/ui/src/app/services/javascript-editor-completion.ts b/ui/src/app/services/javascript-editor-completion.ts
new file mode 100644
index 0000000000..e63d037cd0
--- /dev/null
+++ b/ui/src/app/services/javascript-editor-completion.ts
@@ -0,0 +1,203 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ *
+ */
+
+import type * as monacoType from 'monaco-editor';
+
+export interface JavaScriptEventField {
+    runtimeName: string;
+    propertyScope?: string;
+    semanticType?: string;
+}
+
+type JavaScriptCompletionTemplate = Omit<
+    monacoType.languages.CompletionItem,
+    'kind' | 'range'
+>;
+
+function createJavaScriptUtilsCompletions(
+    monaco: typeof monacoType,
+): JavaScriptCompletionTemplate[] {
+    return [
+        {
+            label: 'addTimestamp',
+            insertText: 'addTimestamp(event)',
+            detail: 'utils.addTimestamp(event, fieldName = "timestamp")',
+            documentation:
+                'Adds the current time in milliseconds to the event and returns the updated event.',
+            filterText: 'utils.addTimestamp addTimestamp',
+            sortText: '0000_addTimestamp',
+        },
+        {
+            label: 'rename',
+            insertText: 'rename(event, "${1:oldName}", "${2:newName}")',
+            insertTextRules:
+                monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+            detail: 'utils.rename(event, oldName, newName)',
+            documentation:
+                'Copies a field to a new name, removes the old field, and returns the updated event.',
+            filterText: 'utils.rename rename',
+            sortText: '0001_rename',
+        },
+        {
+            label: 'remove',
+            insertText: 'remove(event, "${1:fieldName}")',
+            insertTextRules:
+                monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+            detail: 'utils.remove(event, fieldName)',
+            documentation:
+                'Deletes a field from the event and returns the updated event.',
+            filterText: 'utils.remove remove',
+            sortText: '0002_remove',
+        },
+        {
+            label: 'parseTimestamp',
+            insertText: 'parseTimestamp(event, "${1:dateField}")',
+            insertTextRules:
+                monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+            detail: 'utils.parseTimestamp(event, sourceField, targetField = "timestamp")',
+            documentation:
+                'Parses a date field into epoch milliseconds, stores it in timestamp by default, and returns the updated event.',
+            filterText: 'utils.parseTimestamp parseTimestamp',
+            sortText: '0003_parseTimestamp',
+        },
+    ];
+}
+
+function createJavaScriptOutCompletions(
+    monaco: typeof monacoType,
+): JavaScriptCompletionTemplate[] {
+    return [
+        {
+            label: 'collect',
+            insertText: 'collect(${1:event})',
+            insertTextRules:
+                monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+            detail: 'out.collect(event)',
+            documentation: 'Emits a transformed event to the output collector.',
+            filterText: 'out.collect collect',
+            sortText: '0000_collect',
+        },
+    ];
+}
+
+function createJavaScriptContextCompletions(
+    monaco: typeof monacoType,
+): JavaScriptCompletionTemplate[] {
+    return [
+        {
+            label: 'client',
+            insertText: 'client()',
+            detail: 'ctx.client()',
+            documentation:
+                'Returns the StreamPipes client exposed to the script context.',
+            filterText: 'ctx.client client',
+            sortText: '0000_client',
+        },
+    ];
+}
+
+function isTimestampField(field: JavaScriptEventField): boolean {
+    return field.semanticType?.toLowerCase().includes('timestamp') ?? false;
+}
+
+function eventFieldDetail(field: JavaScriptEventField): string {
+    if (isTimestampField(field)) {
+        return `event.${field.runtimeName} (timestamp)`;
+    }
+
+    if (field.propertyScope) {
+        return `event.${field.runtimeName} (${field.propertyScope.toLowerCase().replaceAll('_', ' ')})`;
+    }
+
+    return `event.${field.runtimeName}`;
+}
+
+export function registerJavaScriptCompletionProvider(
+    monaco: typeof monacoType,
+    eventFields: () => JavaScriptEventField[],
+): monacoType.IDisposable {
+    const utilsCompletions = createJavaScriptUtilsCompletions(monaco);
+    const outCompletions = createJavaScriptOutCompletions(monaco);
+    const contextCompletions = createJavaScriptContextCompletions(monaco);
+
+    return monaco.languages.registerCompletionItemProvider('javascript', {
+        triggerCharacters: ['.'],
+        provideCompletionItems: (model, position) => {
+            const linePrefix = model.getValueInRange({
+                startLineNumber: position.lineNumber,
+                startColumn: 1,
+                endLineNumber: position.lineNumber,
+                endColumn: position.column,
+            });
+            const word = model.getWordUntilPosition(position);
+            const range = {
+                startLineNumber: position.lineNumber,
+                endLineNumber: position.lineNumber,
+                startColumn: word.startColumn,
+                endColumn: word.endColumn,
+            };
+
+            if (/(?:^|[^\w$])event\.(\w*)$/.test(linePrefix)) {
+                return {
+                    suggestions: eventFields().map(field => ({
+                        label: field.runtimeName,
+                        kind: monaco.languages.CompletionItemKind.Property,
+                        insertText: field.runtimeName,
+                        filterText: `event.${field.runtimeName} ${field.runtimeName}`,
+                        detail: eventFieldDetail(field),
+                        documentation:
+                            'Field from the current sample event. Selecting it inserts the runtime name.',
+                        range,
+                    })),
+                };
+            }
+
+            if (/(?:^|[^\w$])utils\.(\w*)$/.test(linePrefix)) {
+                return {
+                    suggestions: utilsCompletions.map(item => ({
+                        ...item,
+                        kind: monaco.languages.CompletionItemKind.Method,
+                        range,
+                    })),
+                };
+            }
+
+            if (/(?:^|[^\w$])out\.(\w*)$/.test(linePrefix)) {
+                return {
+                    suggestions: outCompletions.map(item => ({
+                        ...item,
+                        kind: monaco.languages.CompletionItemKind.Method,
+                        range,
+                    })),
+                };
+            }
+
+            if (/(?:^|[^\w$])ctx\.(\w*)$/.test(linePrefix)) {
+                return {
+                    suggestions: contextCompletions.map(item => ({
+                        ...item,
+                        kind: monaco.languages.CompletionItemKind.Method,
+                        range,
+                    })),
+                };
+            }
+
+            return { suggestions: [] };
+        },
+    });
+}