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: [] };
+ },
+ });
+}