TouK/nussknacker

This system is Nussknacker, a low-code platform for designing and executing real-time decision algorithms and data processing scenarios. It provides a visual designer for constructing workflows with sources, sinks, and enrichers, supported by a robust backend engine that handles type checking, validation, and execution. The platform enables users to define complex logic through expression builders, manage scenario metadata, and integrate with external services via dynamic components like OpenAPI and SQL.

144 changes.

This period focused on establishing the Nussknacker Lite engine as a standalone runtime for lightweight streaming and request-response scenarios, complete with Kubernetes deployment support and embedded execution. It also involved a comprehensive refactoring of the core component and deployment manager APIs to introduce stricter type safety, structured validation, and a canonical scenario graph model.

101 changes.

This period focused on a comprehensive overhaul of the designer client, migrating the codebase to TypeScript, Redux Toolkit, and Material-UI while restructuring the application shell and state management. It introduced significant new features including touch support, sticky notes, local draft persistence, and pluggable authentication strategies. Concurrently, the backend was enhanced with configurable deployment status caching, custom HTTP service plugins, and improved fragment resolution logic.

115 changes.

This period focused on a comprehensive redesign of the Nussknacker Designer UI, introducing advanced features such as scenario labels, configurable toolbars, and a dedicated testing tab with assertion and mock capabilities. The backend was significantly refactored to support these changes, including the implementation of periodic process scheduling, robust deployment status tracking, and enhanced live data visualization. Additionally, the release expanded the component library with new Flink Table API and streaming aggregation tools, while establishing a standardized, database-backed test infrastructure for the entire platform.

15 changes.

This period focused on enhancing the designer's testing capabilities by introducing a comprehensive test case management panel, visual assertion feedback, and robust scenario-level validation logic. Concurrently, the platform expanded its operational resilience by implementing a high-availability mode with PostgreSQL-backed leader election for the Designer server.

The AI Assistant now supports executing frontend tools defined by the application. This change introduces a permission system where tool execution can be gated by user confirmation or saved preferences (allow/always allow/deny), managed via \useCheckPermission\. It adds infrastructure for handling tool calls, including a \PendingHumanResolvers\ store for managing asynchronous tool results, a \ThreadIdManager\ for conversation context, and a \ModelAdapter\ that integrates with the \@assistant-ui/react\ runtime to stream tool execution requests and results. A \useFrontendAiTool\ hook allows components to register tools with specific parameters and execution logic, while \withAbort\ ensures tool calls respect cancellation signals.

designer/client/src/components/aiAssistant · high confidence

A new Decision Table component is now available in the common components library. It allows users to define a tabular dataset and a match condition expression (evaluated against each row via a ROW variable) to filter the table, outputting the matching rows as a list of maps.

engine/common/components · high confidence

Introduces a new InfluxDB reporter for process execution counts, allowing users to track node-level metrics via InfluxDB. The implementation includes configuration for connection details, query modes (single difference, sum of differences, and handling restarts), and custom metric/tag naming. It provides an API to fetch counts for specific points in time or date ranges, with logic to detect scenario restarts and adjust queries accordingly to ensure accurate count aggregation.

designer/processReports · high confidence

A new AddButton component has been introduced in the node modal's row fields provider, allowing users to add new fields to a node configuration. The button is conditionally rendered based on the availability of the 'add' action from the FieldsControl context and includes translation support for accessibility and internationalization.

designer/client/src/components/graph/node-modal/node-row-fields-provider/buttons · high confidence

A new utility object \DBIOActionInstances\ has been added to the database utility package, providing a \Monad\ type class instance for Slick's \DBIOAction\. This allows database actions to be treated as monadic values, enabling functional composition and chaining of database operations using standard Cats Monad methods like \flatMap\ and \pure\.

designer/server/src/main/scala/db/util · high confidence

The fragment input definition UI now includes dedicated Remove and Settings buttons. The Remove button allows users to delete a field, while the Settings button provides access to options, visually indicating its active state via theme-based styling.

designer/client/src/components/graph/node-modal/fragment-input-definition/buttons · high confidence

A new type declaration file has been introduced to define global constants (\_\DEV\\, \\_BUILD\VERSION\\, \\_BUILD\HASH\\_) and declare module types for CSS, SVG, and raw-loader imports. This change provides explicit TypeScript definitions for these runtime values and import patterns, ensuring type safety for these specific module resolutions within the designer client.

designer/client/types · high confidence

The Deploy with Parameters modal now includes an Advanced Parameters section that allows users to configure specific action parameters during deployment. This new UI fetches parameter definitions from the backend, groups them by component, and renders editable fields using the existing editor infrastructure, with values persisted in local storage for expanded state. Users can now set and validate these advanced parameters before confirming the deployment action.

designer/client/src/components/modals/DeployWithParameters · high confidence

The system now uses a new \AdditionalInfoProviders\ component to dynamically load and execute \AdditionalInfoProvider\ extensions via Scala ServiceLoader for each processing type. This allows the UI to fetch extra context for specific process nodes and general process metadata (properties) in a unified, type-aware manner, replacing previous ad-hoc or less structured retrieval logic.

designer/server/src/main/scala/pl/touk/nussknacker/ui/additionalInfo · high confidence

The toolbar settings now use a centralized mapping system (\buttonsMap\) to define and render toolbar actions, consolidating logic for built-in operations (such as save, deploy, edit, and test functions) and custom actions. This change introduces a new \LinkButton\ component, enabling users to add custom external links to the toolbar via the \custom-link\ type. The refactoring also establishes a strict type system (\types.ts\) to ensure type safety across button definitions and props.

designer/client/src/components/toolbarSettings/buttons · high confidence

The system now supports caching scenario deployment statuses to reduce load on the underlying deployment manager. A new \CachingProcessStateDeploymentManager\ wraps the existing deployment manager, storing status results in an in-memory cache (via Caffeine) for a configurable duration. This caching is controlled by the \scenarioStateCaching\ configuration block, which allows users to enable the feature and specify the time-to-live (TTL) for cached entries. When enabled, status queries may return cached data instead of hitting the delegate manager immediately, improving performance for frequent status checks.

designer/deployment-manager-api/src/main/scala/pl/touk/nussknacker/engine/api/deployment/cache · high confidence

Users can now configure a namespace prefix and a custom separator for component names via the model configuration. The new NamingStrategy reads the 'namespace' and optional 'namespaceSeparator' settings (defaulting to an underscore) to automatically prepend the prefix to component names and strip it when decoding, enabling consistent namespacing across the engine.

components-api/src/main/scala/pl/touk/nussknacker/engine/api/namespaces · high confidence

The designer now supports defining scenario toolbar layouts via configuration, allowing different toolbars for default and specific process categories. Toolbar buttons and panels can be conditionally hidden or disabled based on user roles, process fragments, or archive status, enabling administrators to tailor the UI experience per category and user permission level.

designer/server/src/main/scala/pl/touk/nussknacker/ui/config/scenariotoolbar · high confidence

Developers building custom HTTP services can now access the database reference (DbRef) and scenario management capabilities directly through the service provider API. The new \NussknackerServicesForCustomHttpService\ class injects both the \DbRef\ and a \ScenarioService\ (which provides methods to query latest scenarios and versions) into the service creation context, enabling custom endpoints to interact with the application's data and process state without needing to implement these services from scratch.

designer/custom-http-service-api · high confidence

Added a new Flink metrics reporter wrapper that defers metric removal until the next scheduled report cycle. This ensures that metrics from short-lived or finished jobs are fully flushed with their last known values before being unregistered, addressing potential data loss in metrics backends like InfluxDB. Users can enable this by configuring the new factory class to wrap their existing reporter.

engine/flink/metrics-deferred-reporter · high confidence

A new ExtraScriptsListingPreparer component has been added to the designer server to support dynamically injecting custom JavaScript files into the main.html page without rebuilding the application image. This feature allows users to mount a directory of .js files (e.g., via Docker volumes) which are then automatically included in the UI in lexicographic order, enabling flexible, runtime customization of the frontend behavior.

designer/server/src/main/scala/pl/touk/nussknacker/ui/extrajs · high confidence

The scenario test button in the toolbar now provides richer visual feedback and supports multiple test cases. It displays an assertion status icon overlay (success, error, or no assertions) on the test button based on the latest test results. Additionally, the button's dropdown menu now lists individual test cases alongside a 'Run all' option, allowing users to select and run specific test cases or execute all of them for the current scenario.

designer/client/src/components/toolbars/test/buttons/scenarioTestButtonContent · high confidence

The notification component has been updated to allow users to copy the full text of error alerts. When a notification is of the 'error' type, a tooltip appears on hover containing a button that copies the message and any associated details to the clipboard, providing a convenient way to capture error information for troubleshooting.

designer/client/src/components/notifications · high confidence

Users can now define specific metadata for fragments via scenario properties, including selecting a visual icon for the Creator panel, assigning the fragment to a specific component group, and linking to external documentation. This change introduces the server-side configuration and validation logic (FragmentPropertiesConfig and associated determiners) that enables these properties to be defined and enforced, allowing for better organization and discoverability of fragments within the design interface.

designer/server/src/main/scala/pl/touk/nussknacker/ui/definition/scenarioproperty · high confidence

The designer now includes a dedicated FragmentRepository and FragmentResolver to manage and resolve process fragments. The repository handles fetching the latest active fragments for a given processing type and retrieving specific fragment details by name, while the resolver integrates with the compilation engine to validate and resolve fragment references within a canonical process, ensuring that fragment dependencies are correctly identified and validated during the editing process.

designer/server/src/main/scala/pl/touk/nussknacker/ui/process/fragment · high confidence

The system now includes an abstraction layer for storing frontend statistics, defined by the new FEStatisticsRepository trait and its read/write sub-traits. A NoOp implementation is provided to allow the application to run without persisting these statistics, effectively disabling the feature by default until a concrete storage backend is wired in.

designer/server/src/main/scala/pl/touk/nussknacker/ui/db/timeseries · high confidence

The designer client now includes a new event-tracking module that collects frontend usage statistics and error reports. When enabled in feature settings, the system tracks user interactions such as clicks, filters, sorts, searches, and keyboard actions by reading data attributes on DOM elements, sending aggregated event names to a backend endpoint. Additionally, it initializes Elastic APM RUM to capture runtime errors and performance data, providing visibility into UI stability and usage patterns.

designer/client/src/containers/event-tracking · high confidence

The Designer now supports a high availability mode that enables leader election across multiple instances using a PostgreSQL-backed distributed lock. When enabled via configuration, instances compete for a leader lock with configurable heartbeat intervals, lease durations, and query timeouts; the system provides callbacks for leadership acquisition and loss, ensuring coordinated operation in multi-node deployments. If HA is disabled, the instance operates as a single-node leader.

designer/server/src/main/scala/pl/touk/nussknacker/ui/ha · high confidence

The \designer/submodules\ directory has been initialized as a new npm workspaces monorepo containing the React 18 and TypeScript 5.9 frontend components for the Nussknacker designer. This location now provides the build configuration (Babel, ESLint, Prettier, TypeScript), environment setup (Node 20.10.0, Docker), and architectural documentation (AGENTS.md) required to develop and run the submodule as a Webpack Module Federation remote. This change establishes the development environment and tooling for the \@nu/components\ package, which exposes the list and scenarios views to the host application.

designer/submodules · high confidence

This change introduces the foundational backend service and frontend type definitions for scenario labels. The server-side \ScenarioLabelsService\ now provides the capability to retrieve available labels for a user and validate label inputs, while the client-side \types.ts\ file defines the TypeScript interfaces for available labels and validation error responses, enabling the UI to display and manage scenario labels.

designer/client/src/components/Labels, designer/server/src/main/scala/pl/touk/nussknacker/ui/process/label · high confidence

The designer now includes a new AI Assistant feature, implemented in the \aiAssistant/components\ directory. Users can open a resizable, draggable chat window via a floating button or the command palette (shortcut 'a', 'i'). The interface supports threaded conversations with a composer for sending messages, auto-scrolling, and a 'Reset Thread' option. Assistant responses are rendered as Markdown with options to copy or refresh the answer. The assistant also supports tool calls, allowing users to resolve human-in-the-loop actions directly within the chat.

designer/client/src/components/aiAssistant/components · high confidence

This change adds the K8s Deployment Manager for Nussknacker Lite, enabling scenarios to be deployed as Kubernetes Deployments, Services, and optional Ingresses. It includes a provider registration, default configuration templates for minimal deployments and ingress, and a logback configuration for runtime pods. The manager handles deployment preparation, scaling options, resource quota checks, and status mapping from Kubernetes objects to scenario states.

engine/lite/k8sDeploymentManager · high confidence

Adds the \LiteDeploymentManager\ and its provider to handle scenario deployment and testing for the Nussknacker Lite engine. The manager supports both streaming and request-response execution modes, routing test execution to the appropriate interpreter (\KafkaTransactionalScenarioInterpreter\ or \FutureBasedRequestResponseScenarioInterpreter\) based on configuration. The provider initializes metadata (such as parallelism for streaming and slugs for request-response) and defines specific scenario properties like parallelism and slug, ensuring mode-specific configuration is applied during deployment.

engine/lite/deploymentManager · high confidence

The Lite Kafka runtime now supports end-to-end transactional processing for Kafka scenarios, ensuring that records are consumed, processed, and produced atomically. This implementation automatically enables transactions for standard Kafka clusters while disabling them for Azure Event Hubs, which do not support transactional producers. The runtime includes robust error handling, sending failed records to a dedicated error topic, and provides detailed metrics for both consumer and producer activities, including task attempts and restart status. Additionally, event timestamps are preserved from source to sink, and the system handles offset commits correctly within transaction boundaries.

engine/lite/kafka/runtime · high confidence

Users can now add an OpenAPI component to their scenarios to dynamically invoke external REST services defined by a Swagger/OpenAPI specification. The component automatically discovers endpoints from a provided URL or file, generates typed parameters for path, query, and body inputs, and handles HTTP requests using an asynchronous HTTP client. It supports multiple security schemes, including API keys (in headers, query, or cookies), HTTP Basic Authentication, and OAuth2 Client Credentials, allowing secure integration with protected APIs. The component also includes caching for the API definition to improve performance and resilience.

components/openapi/src/main · high confidence

This change introduces the \components-api\ module for the Request-Response engine, providing the foundational Scala traits and configuration structures needed to define request-response sources. It adds \RequestResponseSourceFactory\ and related source traits (\RequestResponseGetSource\, \RequestResponsePOSTSource\) that handle request parsing, trace ID extraction from headers, and context initialization. Additionally, it defines \ResponseEncoder\ for custom JSON serialization, \OpenApiSourceDefinition\ for exposing API specifications, and \RequestResponseOpenApiSettings\ which configures mandatory input and output schema properties for scenarios.

engine/lite/request-response/components-api · high confidence

This change introduces new core types for the scenario validation engine: \ContextTransformation\ and \JoinContextTransformation\ to define how variable contexts are transformed during node execution, \ValidationContext\ to manage local and global variable scopes with parent-child relationships, and a comprehensive \ProcessCompilationError\ hierarchy to categorize validation failures (such as missing services, duplicated parameters, or invalid expressions) by scope and node. These additions provide a structured foundation for component context handling and error reporting within the \components-api\.

components-api/src/main/scala/pl/touk/nussknacker/engine/api/context · high confidence

Adds a new standalone runtime application (\NuRuntimeApp\) for executing Nussknacker Lite scenarios, including the main entry point, scenario interpreter factory, and deployment data models. The runtime accepts a scenario JSON and deployment data file as arguments, starts an HTTP server (default port 8080) using Apache Pekko, and exposes health check routes to monitor the interpreter's running status. It also includes shell scripts (\run.sh\, \nu-engine-entrypoint.sh\) for launching the JVM with necessary module opens, Prometheus JMX agent support, and configuration for Kafka and schema registry connections.

engine/lite/runtime-app · high confidence

A new Test Cases panel has been added to the designer toolbar, allowing users to view, run, and manage multiple test cases within a scenario. The panel features a toggle to switch between 'Results' and 'Definitions' views: the Results view displays per-node assertion outcomes with pass/fail badges and detailed error messages, while the Definitions view lists the sources, mocks, and assertions configured for the scenario. Users can run individual test cases or all tests at once, and the interface highlights nodes in the graph when interacting with their definitions.

designer/client/src/components/toolbars/testCases · high confidence

The designer server now supports storing frontend usage statistics in QuestDB. This change adds a new QuestDB integration layer that includes configuration for enabling/disabling the feature, a repository implementation to aggregate and write statistics, and scheduled tasks to flush data to the database and enforce retention policies by dropping old partitions. It also introduces custom Cairo configuration to disable telemetry and set query timeouts, along with utility classes for object pooling and task recovery to ensure robustness.

designer/server/src/main/scala/pl/touk/nussknacker/ui/db/timeseries/questdb · high confidence

The AWS Managed Flink Deployment Manager now includes an uber-jar assembler that combines multiple dependency JARs into a single executable JAR. This change introduces a flexible merge strategy system (Concat, Discard, Deduplicate, FilterDistinctLines, First, and Rename) to handle conflicting entries from different libraries. By default, identical files are deduplicated, while service files in META-INF/services are merged by distinct lines, and license/readme files are renamed to avoid conflicts. This ensures that deployed Flink applications have a consistent, conflict-free classpath and manifest, resolving issues that previously arose when merging complex dependency trees.

engine/flink/aws-managed-flink-deployment-manager · high confidence

This change adds a suite of new value classes and utilities to the common-api to support refined scenario modeling and serialization. It introduces \NodeId\ and \NodeName\ to replace raw strings for node identification, and \ProcessName\ and \ProcessId\ to distinguish between human-friendly slugs and database identifiers. The \MetaData\ and \TypeSpecificData\ structures are expanded to support specific metadata types like \StreamMetaData\, \LiteStreamMetaData\, \RequestResponseMetaData\, and \FragmentSpecificData\, enabling richer configuration for different scenario types. Additionally, the \Expression\ class is enhanced with support for multiple languages including \JsonTemplate\ and \SpelTemplate\, and a new \TabularTypedData\ type is added to handle structured tabular data. JSON serialization is standardized using Circe with custom codecs in \CirceUtil\, and helper classes like \Comment\ and \FixedExpressionValue\ are introduced to improve type safety in parameter definitions.

common-api · high confidence

The Auth container now supports multiple authentication strategies via a new modular architecture. New components including AuthInitializer, StrategySelector, and StrategyInitializer allow the application to dynamically select and initialize authentication providers based on configuration settings. This includes a defined Strategy interface for intercepting API errors and handling initialization, along with specific error code definitions and an error display component, enabling flexible authentication flows without hardcoding a single method.

designer/client/src/containers/Auth · high confidence

The runtime context API now exposes a dedicated ContextIdGenerator trait and an IncContextIdGenerator implementation to produce unique, readable context IDs for nodes, scenarios, and tasks. EngineRuntimeContext provides access to job data, metrics, and the context ID generator, enabling components to generate consistent identifiers during execution.

components-api/src/main/scala/pl/touk/nussknacker/engine/api/runtimecontext · high confidence

The engine now includes a new \development/deploymentManager\ module that provides two specialized deployment managers for non-production environments. The \DevelopmentDeploymentManager\ simulates deployment lifecycles (including validation and deployment failures) using an in-memory state store and a reusable Flink mini-cluster for scenario testing, while the \MockableDeploymentManager\ allows test code to programmatically configure scenario statuses, deployment results, and test outcomes. These components are registered via the standard Java SPI mechanism and include a dedicated UI icon for the test-deploy action.

engine/development/deploymentManager · high confidence

The engine/lite/kafka/components-api module now includes a new LiteKafkaSource trait, which serves as the foundational component for Kafka sources in the Lite engine. This trait extends BaseLiteSource and implements trace ID extraction logic by reading from a specific header in Kafka ConsumerRecords, enabling distributed tracing capabilities for Kafka-based data flows within this specific API layer.

engine/lite/kafka/components-api · high confidence

The listener API now exposes a new \PullProcessRepository\ trait within the \NussknackerServices\ container, providing methods to fetch latest process details, specific version details, and scenario activities. This change introduces the interface for retrieving process metadata and activity logs, serving as the data access layer for process-related queries in the listener component.

designer/listener-api/src/main/scala/pl/touk/nussknacker/ui/listener/services · high confidence

The default model module now includes its own configuration file (defaultModelConfig.conf) and service provider registrations. The configuration defines documentation URLs for core components such as filter, variable, choice, and split, linking to specific sections in the user documentation. Service files register the DefaultConfigCreator and DefaultModelMigrations, establishing the default model's configuration and migration behavior within the engine.

defaultModel/src/main/resources · high confidence

The default model now registers a set of global expression helpers (GEO, NUMERIC, CONV, COLLECTION, DATE, DATE\_FORMAT, UTIL, RANDOM, BASE64) accessible in any category, and defines a migration pipeline that handles schema updates for components such as GroupBy, SinkExpression, RequestResponseSink, DecisionTable, Periodic/SampleGenerator sources, SpelToSpelTemplate, PreviousValue parameters, NodeId/Uuid, and CustomNodeOutputs (deduplication).

defaultModel/src/main/scala/pl/touk/nussknacker/defaultmodel · high confidence

The designer server now includes a new counts reporting subsystem. A factory (CountsReporterFactory) initializes a reporter (defaulting to InfluxDB) based on configuration, while a new ProcessCounter component calculates execution metrics (total and error counts) for individual nodes within a process, including handling nested fragment invocations. This enables the system to track and report detailed process execution statistics.

designer/server/src/main/scala/pl/touk/nussknacker/ui/processreport · high confidence

The designer now includes a new service layer for managing and validating scenario graph versions. This change introduces a repository and service that retrieve the latest scenario graph version from the database, validate it against the current processing type configuration, and resolve the canonical process. This ensures that scenarios are validated and resolved consistently before being used, providing a robust mechanism for handling scenario graph integrity within the designer's backend.

designer/server/src/main/scala/pl/touk/nussknacker/ui/process/version · high confidence

This change introduces a new \NuDesignerError\ hierarchy in the UI module, providing specific error types such as \UnauthorizedError\ and \NotFoundError\ to replace generic exceptions with structured, domain-specific failures. It also adds the \NussknackerApp\ entry point, which initializes the application using \NussknackerAppFactory\ and \AlwaysLoadingFileBasedDesignerConfigLoader\, and implements \ProcessChangeListenerLoader\ to aggregate and safely handle process change events via service loaders.

designer/server/src/main/scala/pl/touk/nussknacker/ui · high confidence

The Lite engine now registers a set of core components via the new \LiteBaseComponentProvider\. This includes a \for-each\ transformer that iterates over a collection with a default value of \{"item1", "item2"}\, a \union\ join node that strictly validates that all branch outputs share the same type structure (checking field keys for objects), a \dead-end\ sink for discarding data, and a \decision-table\ component. These components are now available for use in Lite scenarios.

engine/lite/components/base · high confidence

The Lite engine can now use Kafka as a data source and sink through the new \LiteKafkaComponentProvider\. This provider registers \UniversalKafkaSourceFactory\ and \UniversalKafkaSinkFactory\, enabling Lite processes to read from and write to Kafka topics with schema support. The implementation includes \LiteKafkaSourceImplFactory\ and \LiteKafkaUniversalSinkImplFactory\ to handle Lite-specific execution details, such as event timestamp handling in sources and lazy parameter evaluation in sinks. Configuration validation ensures that Flink-specific features like idleness and sink delivery guarantees are not used in Lite contexts.

engine/lite/components/kafka · high confidence

The designer now persists scenario drafts to the browser's local storage, allowing users to recover unsaved work if the page is refreshed or closed. This change introduces a new \draftStorage\ module with a \localStorageBackend\ implementation and corresponding Redux actions (\scenarioDraftSet\, \scenarioDraftHydrate\, \scenarioDraftClear\) to manage the lifecycle of these drafts, ensuring that the current graph state is saved and can be re-applied later.

designer/client/src/actions · high confidence

A new @GenericType annotation has been added to the components-api module, allowing developers to define logic that calculates a method's return type based on its argument types. This enables more flexible and dynamic type inference within the engine's generic type system.

components-api/src/main/java/pl/touk/nussknacker/engine/api/generics · high confidence

The AI assistant now supports several new frontend tools that allow it to interact directly with the designer's state. Users can now ask the assistant to list available scenarios, open specific scenarios in the editor, retrieve raw scenario data (including draft changes), and modify scenario graph values atomically. Additionally, a new validation tool allows the assistant to check scenario status, while a debug tool and mock fetch utilities are included to facilitate testing and development of these AI capabilities.

designer/client/src/components/aiAssistant/debug · high confidence

The \components-api\ module now exposes core traits and factories for defining data sources and sinks, including \SourceFactory\ and \SinkFactory\ with helper methods for unbounded streams. It introduces \ContextInitializer\ to handle the transformation of raw events into initial context variables, replacing previous ad-hoc logic. Additionally, \ComponentUseContext\ defines whether a component runs in live runtime or scenario testing, and \TopicName\ provides a type-safe distinction between source and sink topic names.

components-api/src/main/scala/pl/touk/nussknacker/engine/api/process · high confidence

The components-api module introduces several new types to enhance expression evaluation and context management. Context now supports optional TraceId for better correlation and tracing across system components. A new TemplateEvaluationResult type allows SpEL expression parts to be evaluated and rendered as distinct literal or sub-expression parts within LazyParameter contexts. Parameter handling is refined with ParameterEvaluationResult to distinguish between eager and lazy evaluation outcomes, and Params now provides methods to extract or evaluate declared lazy parameters directly from the context. Additionally, ValueWithContext is added to carry evaluation results alongside their source context.

components-api/src/main/scala/pl/touk/nussknacker/engine/api · high confidence

The designer client now includes a new Activities panel in the toolbar that displays a scrollable, searchable history of scenario events (such as deployments, modifications, and name changes). Users can search across activity details like dates, users, comments, and version IDs, with results highlighting and auto-scrolling. The panel footer provides buttons to add comments and attachments to specific activities, contingent on user write permissions.

designer/client/src/components/toolbars/activities · high confidence

The designer now exposes REST endpoints for listing components and retrieving their usage details, implemented using the Tapir framework. The \/components\ endpoint supports optional \skipUsages\ and \skipFragments\ query parameters to control response payload size, returning a list of \ComponentListElement\ objects that include metadata such as component type, group, categories, documentation links, usage counts, and allowed processing modes. A new \/components/{id}/usages\ endpoint allows users to see exactly which scenarios and nodes reference a specific component, returning detailed usage data including scenario names, node IDs, and modification timestamps. These changes are backed by new REST model classes (\ComponentListElement\, \ComponentUsagesInScenario\, \ScenarioComponentsUsages\) and JSON codecs defined in the \component\ package.

designer/restmodel/src/main/scala/pl/touk/nussknacker/restmodel/component · high confidence

A new Condition Builder UI has been added to the designer client, allowing users to construct and edit SpEL (Spring Expression Language) conditions via a visual interface. This includes a dedicated ConditionBuilder component with a Context Variables tree, an expression preview panel, and support for adding, removing, and combining multiple conditions using AND/OR logic. The builder parses and generates SpEL strings, handles validation errors, and integrates with the existing DataMapper context to provide real variable values. Tests cover rendering, expression parsing, condition management, and context variable filtering.

designer/client/src/components/dataMapper · high confidence

A new CronEditor component has been added to the node modal's expression editors, allowing users to visually create and edit cron expressions using the react-cron-generator library. This editor integrates with the existing expression framework, providing validation hints and styling consistent with the application's theme, specifically enabling users to switch to cron mode when the expression matches the expected Quartz pattern.

designer/client/src/components/graph/node-modal/editors/expression/Cron, designer/client/src/components/graph/node-modal/editors/map · high confidence

A new CustomRadio component has been added to the designer client, providing a styled radio-button-like selection control built on MUI's Checkbox, MenuItem, and Paper components. It supports labels, icons, disabled states, and active indicators, and includes tests to verify rendering, disabled/active states, and change event handling.

designer/client/src/components/customRadio · high confidence

A new DbRef class and associated NuJdbcProfile traits have been added to the components-api module, providing a standardized way for components to access database connections and profiles with enforced schema handling. This introduces support for PostgreSQL and HSQLDB profiles within the component provider API, enabling components to interact with the database in a consistent manner.

components-api/src/main/scala/pl/touk/nussknacker/engine/api/db · high confidence

The Flink base components now include a new Deduplication transformer that allows users to filter duplicate events based on a configurable TTL and time mode (event time or processing time), with support for custom filter conditions and multiple outputs (passed/rejected). Additionally, the FlinkBaseComponentProvider is now registered via the standard Java SPI mechanism, ensuring that the base set of Flink components (including ForEach, Union, Delay, PreviousValue, and the new Deduplication) are automatically discovered and loaded by the engine.

engine/flink/components/base · high confidence

This change introduces two new Docker Compose-based examples for running Nussknacker: a production-style installation example (\examples/installation\) and a local development environment (\examples/dev\). The installation example provides a complete stack including the Nussknacker Designer, Flink (1.20.3), PostgreSQL (18), Kafka, Schema Registry, InfluxDB, Grafana, and AKHQ, accessible via a unified Nginx reverse proxy. The local development example mirrors this stack but adds Telegraf for metrics collection and exposes services for easier debugging. Both examples include pre-configured Grafana dashboards for monitoring streaming, lite, and request-response scenarios, along with Flink configurations tuned for memory and RocksDB metrics.

examples · high confidence

The nussknacker-dist package now includes a complete set of startup scripts (nussknacker-entrypoint.sh, run.sh) and configuration files designed for Docker deployment. Users can now enable Prometheus metrics by setting the PROMETHEUS\_METRICS\_PORT environment variable, which automatically loads the JMX Prometheus Java agent and applies the provided jmx\_prometheus.yaml configuration. The distribution also supports remote Java debugging via the JAVA\_DEBUG\_PORT environment variable and includes the necessary Java 17 module opens (e.g., java.sql) in the startup options to ensure compatibility with modern JDKs. Default configuration files (application.conf, users.conf) are provided to simplify initial setup with pre-configured Kafka, InfluxDB, and Grafana integrations.

nussknacker-dist · high confidence

The node-modal expression editors now include dedicated Duration and Period editors that allow users to input time values with granular precision. The Duration editor supports days, hours, minutes, seconds, and milliseconds, while the Period editor supports years, months, days, and weeks. These editors parse and generate Java \java.time.Duration\ and \java.time.Period\ expressions respectively, providing a structured UI for editing these specific temporal types.

designer/client/src/components/graph/node-modal/editors/expression/Duration · high confidence

A new EspTimer utility has been added to the components-api module to help track service performance. It combines a RateMeter and a Histogram to record execution deltas in nanoseconds, exposing specific suffixes for histogram and instant rate metrics to facilitate observability.

components-api/src/main/scala/pl/touk/nussknacker/engine/util/service · high confidence

Added a new set of components for the expression builder interface, including ContextTreeNode for rendering context data as an expandable tree with type-aware path generation (SpEL picker), typeUtils for inferring display types and handling null-safe path conversion, aceUtils for managing Ace editor selection after drops, and panelStyles for consistent styling of builder panels and editors.

designer/client/src/components/builderComponents · high confidence

This change introduces new Flink-based Kafka source and sink implementations in the kafka-components-utils module. The Kafka source now supports configurable watermark strategies and allows users to specify offset reset strategies (resume, latest, earliest) during deployment and redeployment actions. The Kafka sink has been migrated to use Flink's Sink2 API, enabling configurable delivery guarantees (exactly-once, at-least-once, none) and transactional ID prefixes based on the node ID. A new Kafka exception consumer has been added to route error records to a dedicated topic, with logic to automatically strip large context variables if they exceed message size limits. Additionally, custom serializers and type information for Kafka ConsumerRecords have been implemented to ensure proper state serialization and deserialization in Flink.

engine/flink/kafka-components-utils · high confidence

This change introduces a new set of components for the Flink Table API, enabling users to perform batch table operations and define table sources/sinks via SQL DDL. Specifically, it adds a 'join' component for combining data streams (supporting INNER and OUTER joins) and an 'aggregate' component for grouping and summarizing data (supporting functions like Average, Count, Max, Min, Sum, and standard deviation). Additionally, it provides a 'table' component for reading from and writing to external data sources, configured through SQL CREATE TABLE and CREATE CATALOG statements parsed by a new DDL parser. These components are registered via the \FlinkTableOpsBatchComponentProvider\ and \FlinkTableIOComponentProvider\ service loaders.

engine/flink/components/table · high confidence

A new \engine/flink/components-api\ module has been introduced to centralize Flink-specific runtime abstractions for scenario components. This change adds \FlinkEngineContext\ to abstract over Flink's \RuntimeContext\ and \WriterInitContext\, \FlinkEngineRuntimeContext\ to bridge the engine context with the platform's \EngineRuntimeContext\, and \NkGlobalParameters\ to pass deployment metadata (such as \deploymentId\, \processVersion\, and \modelInfo\) through Flink's \GlobalJobParameters\. It also introduces \TimeMode\ to support both event-time and processing-time timer registration, \TypedMultiset\ to handle multiset serialization hints, and \FlinkCustomNodeContext\ to provide component implementations with access to job data, lazy parameter evaluation, and exception handling. Furthermore, the module adds \FlinkSink\ and \FlinkSource\ traits to standardize how sinks and sources interact with the Flink DataStream API, along with helper classes like \FlinkLazyParameterFunctionHelper\ and \StatefulFunction\ to simplify stateful processing and lazy parameter evaluation within Flink operators.

engine/flink/components-api · high confidence

The \engine/flink/test-utils\ module now provides a comprehensive suite of tools for testing Flink scenarios, including a Docker-based \WithFlinkContainers\ trait that spins up a Flink 1.20.3 cluster (with configurable memory and logging overrides) alongside Kafka and Schema Registry containers. This location introduces core testing abstractions such as \FlinkSpec\ for mini-cluster setup, \RecordingExceptionConsumer\ for capturing and verifying process exceptions, and \TestReporter\ for inspecting Flink metrics. It also adds serialization helpers (\FlinkTypeInformationSerializationMixin\), result collection utilities (\TestResultsHolder\, \ConfigCreatorWithCollectingListener\), and sample node definitions (\SampleNodes\) to facilitate unit and integration testing of streaming scenarios.

engine/flink/test-utils · high confidence

The engine/flink/components-utils module now includes a suite of new utilities to support complex stream processing patterns. EvictableStateFunction and LatelyEvictableStateFunction provide time-mode-aware state eviction timers for keyed process functions. Keyed value handling is enhanced with KeyedValueType, keyed.scala (including KeyedValueMapper and null-key validation), and richflink.scala (providing groupBy operations on DataStreams). Source and sink capabilities are expanded with BlockingQueueSource and CollectionSource for flexible data ingestion, EmptySink and SingleValueSinkFactory for output handling, and EmptySource/StaticSource for testing. Additionally, exception handling is standardized via DefaultExceptionConsumers (VerboselyLogging and BrieflyLogging) registered through Java SPI, and type information support is improved with ConcreteCaseClassTypeInfo and FixedValueTypeInformationHelper.

engine/flink/components-utils · high confidence

This change introduces a new \utils/http-utils\ module that provides a reusable HTTP client infrastructure. It replaces the previous Akka HTTP backend with AsyncHttpClient via Sttp, adding configurable timeouts, connection pooling, and the ability to forbid specific CIDRs to prevent SSRF attacks. It also includes comprehensive request/response logging with correlation IDs for debugging, robust error handling that exposes user-friendly messages while hiding stack traces, and support for OAuth2 client credentials authentication with automatic token caching and retry logic on 401 errors.

utils/http-utils · high confidence

A new InitializeError component has been added to the error handling system to provide specific, user-friendly messages for initialization and authentication issues. It displays full-screen error states for scenarios such as unauthorized access (401), gateway timeouts (504), unexpected application errors, and authentication token problems, offering appropriate retry or refresh actions for each case.

designer/client/src/containers/errors · high confidence

The \utils/json-utils\ module now provides a complete set of components for handling JSON schemas, including parsing (\JsonSchemaBuilder\), type extraction (\SwaggerBasedJsonSchemaTypeDefinitionExtractor\), and validation (\JsonSchemaOutputValidator\). This infrastructure enables schema-driven parameter editors (\JsonSchemaBasedParameter\) and robust encoding/decoding (\ToJsonSchemaBasedEncoder\, \CirceJsonDeserializer\) that respect schema constraints, default values, and nullable types for JSON-based sinks and sources.

utils/json-utils · high confidence

Added JsonRequestResponseSourceFactory, which allows users to define a request-response source that parses incoming JSON payloads into typed objects and supports testing via file-based records. Also added SchemaResponseEncoder, which encodes scenario results into JSON responses validated against a provided JSON Schema, ensuring output conforms to the defined structure before being returned.

engine/lite/request-response/components-utils · high confidence

Developers can now implement dynamic components in Java using the new \JavaDynamicComponent\ trait and its specialized variants (\JavaSingleInputDynamicComponent\, \JavaJoinDynamicComponent\, \JavaSourceFactoryDynamicComponent\). This API allows Java-based components to participate in the dynamic context transformation flow, handling parameter validation, state management, and node dependencies through Java-friendly types like \java.util.List\ and \java.util.Optional\.

components-api/src/main/scala/pl/touk/nussknacker/engine/javaapi · high confidence

A new Java-based sample model has been added to the dev-model module, providing a \TestProcessConfigCreator\ and a \Model\ POJO to support Java-specific development and end-to-end testing scenarios. This addition complements the existing Scala sample model by offering a parallel configuration path for Java users, including a dedicated service loader registration and a minimal default model configuration.

engine/flink/management/dev-model · high confidence

A new LiveDataProvider trait and associated data classes (DataRecords, DataRecord) have been added to the components-api module. This introduces a mechanism for sources to provide common test data, including an upstreamTimestamp field in DataRecord to support timestamp assignment during scenario testing.

components-api/src/main/scala/pl/touk/nussknacker/engine/api/livedata · high confidence

A new MathUtils utility has been added to the utils/math-utils module, providing a comprehensive set of numeric operations including min, max, sum, largeSum, plus, minus, multiply, divide, remainder, and negate. The implementation handles various numeric types (Byte, Short, Int, Long, BigInteger, Float, Double, BigDecimal) with appropriate type promotion strategies, ensuring consistent behavior across different numeric representations. The divide operation specifically addresses BigDecimal scale handling by using the maximum scale of operands with HALF\_EVEN rounding mode, matching SpEL expression behavior. Tests verify correct null handling, type promotion, and BigDecimal scale management.

utils/math-utils · high confidence

A new SpEL Expression Builder component has been added to the designer client, providing a dedicated dialog for constructing and validating SpEL expressions. This tool allows users to browse context variables, search for specific paths, and receive real-time validation feedback against the current process configuration before inserting the expression into a field. The builder is integrated into the UI via a new component wrapper that handles dialog state and context data resolution.

designer/client/src/components/spelExpressionBuilder · high confidence

A new UIProcessResolver class has been introduced to manage the resolution of expressions (such as mapping dictionary labels to keys) and validation steps before a process is saved or returned to the UI. This component coordinates with the UI validator and dictionary substitutor to ensure that canonical processes are correctly transformed into scenario graphs and vice versa, handling both forward resolution for validation and reverse resolution for display.

designer/server/src/main/scala/pl/touk/nussknacker/ui/uiresolving · high confidence

The view toolbar now includes dedicated buttons for resetting the view, zooming in, and zooming out. The Reset View button dispatches a toolbar reset action and triggers the graph to fit its content. The Zoom In and Zoom Out buttons dispatch corresponding zoom actions to the graph context, with availability controlled by the disabled state and the presence of an active graph instance.

designer/client/src/components/toolbars/view · high confidence

The search toolbar now includes an advanced search panel that allows users to filter nodes by specific attributes such as ID, name, description, type, label, value, output, and edge expressions. This new UI component, located in the search toolbars, introduces structured query parsing and filtering logic, enabling more precise node discovery within the scenario graph compared to simple text matching.

designer/client/src/components/toolbars/search · high confidence

The aggregate node configuration modal now features a dedicated UI for managing aggregations and group-by fields. This change introduces a new React context (AggregateContextProvider) to manage state for aggregator rows and group-by values, replacing previous ad-hoc handling. The UI allows users to add, remove, and reorder aggregation rows, each containing a name, an aggregator type selector (with presets like 'Count'), and a SpEL expression input. A new SpEL parser helper module (pareserHelpers) handles the serialization and deserialization of complex map/list structures used in aggregate parameters, ensuring consistent storage of configuration data. Tests have been added to verify the correctness of the SpEL parsing logic for various input formats.

designer/client/src/components/graph/node-modal/aggregate · high confidence

The application now includes concrete implementations for three authentication strategies: OAuth2, Browser, and Remote. The OAuth2 strategy handles authorization code and implicit grant flows, including JWT token verification and nonce validation. The Browser strategy manages basic and digest authentication by clearing stale tokens. The Remote strategy integrates with an external authentication module via module federation, wrapping the remote component with an error boundary and handling token retrieval. These strategies are registered in a central index, allowing the application to switch between authentication methods based on configuration.

designer/client/src/containers/Auth/strategies · high confidence

This change introduces the \base-unbounded\ component provider, registering core streaming capabilities including the \event-generator\ source, \union-memo\ transformer, and sliding/tumbling/session window aggregators. The aggregation system is rebuilt with a new \Aggregator\ abstraction supporting functions like median, standard deviation, and approximate cardinality, while stateful transformers like \TransformStateTransformer\ and \UnionWithMemoTransformer\ now utilize time-aware eviction timers for more efficient state management.

engine/flink/components/base-unbounded · high confidence

The components-api module introduces a suite of new annotations that allow component developers to define parameter metadata, control visibility, and specify expression languages. Key additions include @Hidden and @HideType to suppress parameters from code completion and expressions, @Label and @HintText to provide user-facing descriptions, @DefaultValue to set default values with configurable expression languages (via the new ExpressionLanguage enum), and @ParameterCategory to distinguish between standard and advanced parameters. Additional annotations like @AdditionalVariable, @BranchParamName, @Documentation, and @MethodToInvoke provide further control over variable injection, branch logic, and component method invocation.

components-api/src/main/java/pl/touk/nussknacker/engine/api · high confidence

The components-api module introduces a new set of traits and data classes to standardize how component metadata and UI settings are provided to the designer. This includes the \AdditionalUIConfigProvider\ and its factory, which allow external components to supply dynamic UI configurations for both individual components (such as icons, documentation URLs, and parameter hints) and scenario properties. The API also defines \ComponentConfig\ and \ComponentDefinition\ structures that support grouping components via \ComponentGroupName\, assigning labels, and explicitly disabling components. Furthermore, it establishes a robust identification system using \ComponentId\ and \DesignerWideComponentId\ to handle component uniqueness across different processing types, alongside \ProcessingMode\ enums to restrict components to specific execution modes like Request-Response or Stream processing.

components-api/src/main/scala/pl/touk/nussknacker/engine/api/component · high confidence

This change introduces a suite of new utility classes and traits in the \utils/components-utils\ module to support component definition, validation, and runtime behavior. It adds \EagerServiceWithErrorSupport\ and \ServiceResponseWithError\ to enable services to return structured error responses with status codes, and \EagerServiceWithStaticParameters\ to simplify the creation of services with dynamic parameter definitions. Validation is enhanced with \SchemaBasedParameter\ and \OutputValidatorErrorsConverter\ for detailed, user-friendly error messages on schema mismatches. Runtime support includes \RuntimeInjectedJobData\ for accessing job context, \TestEngineRuntimeContext\ for testing, and \SharedServiceHolder\ for managing shared resources. Additionally, it provides \WatermarkStrategyValidationHandler\ for configuring Flink watermark strategies in sources, \FlinkDocumentationUrl\ for linking to version-specific documentation, and \TimeMeasuringService\ for tracking service execution times.

utils/components-utils · high confidence

A new \components\ package has been introduced in the designer submodule, exposing \list\ and \scenarios\ views via Module Federation. This package provides a self-contained UI layer including a React bootstrap entry point, a default theme with dark/light mode support, and a suite of shared components such as category and label chips, filter contexts, and table cell renderers. It also includes infrastructure for dynamic icon loading with retry mechanisms and fallbacks, as well as common utilities for text highlighting, truncation, and navigation.

designer/submodules/packages/components · high confidence

A new InfoTooltip component has been added to the node-modal editors, supporting both click-to-open and hover-triggered interaction variants. This component allows users to view contextual help or descriptions via an info icon, with support for markdown-formatted content, customizable placement, and configurable entry delays to improve usability.

designer/client/src/components/graph/node-modal/editors/InfoTooltip · high confidence

Added DocsConfig to manage base documentation URLs and provide a convenient method for attaching relative documentation links to component definitions. Additionally, introduced FicusReaders to enable configuration-based reading of parameter editors, validators, and scenario property configurations using JSON decoding, along with support for non-empty lists in configuration.

components-api/src/main/scala/pl/touk/nussknacker/engine/util/config · high confidence

The designer client now includes a dedicated connection error provider that detects network or backend access issues and displays a user-friendly modal dialog with localized messages. When a connection error is active, the system automatically cancels pending API requests (excluding notifications) to prevent unnecessary traffic and stale state, ensuring the UI remains responsive and consistent during connectivity problems.

designer/client/src/containers/connectionErrorProvider · high confidence

The designer client now includes a set of new custom hooks in the containers/hooks directory to improve state management and UI behavior. useSearchQuery provides robust parsing and stringification of URL query parameters, including manual encoding to handle array delimiters correctly, and supports history state replacement. useModalsIfNeeded centralizes logic for opening node and tool windows based on query parameters, handling fragment node prefixes and specific tool IDs. useSize wraps react-cool-dimensions with a polyfill for ResizeObserver and adds ref support via useSizeWithRef. Additional hooks include useClashedNames for validating scenario names against existing ones, useProcessNameValidators for integrating these checks into forms, useFirstRender for detecting initial mount, and useInitEffect for ensuring callbacks run exactly once, addressing React 18 double-invocation issues.

designer/client/src/containers/hooks · high confidence

The DateTimeEditor module now provides specialized UI components for editing date, time, and datetime expressions. Users can switch between these specific editor modes when the underlying expression is valid, with clear validation hints if the format is incompatible. The implementation uses a shared DatepickerEditor component to handle the UI logic, while DateEditor, TimeEditor, and DateTimeEditor configure the specific moment formats and formatters for each type.

designer/client/src/components/graph/node-modal/editors/expression/DateTimeEditor · high confidence

The \utils/default-helpers\ module now provides a comprehensive set of built-in helper functions for SpEL expressions. Users can encode and decode Base64 strings (including URL-safe variants) via \\#BASE64\. The \\#COLLECTION\ helper offers extensive list and map operations, including \concat\, \merge\, \min\, \max\, \sum\, \sortedAsc\, \sortedDesc\, \sortedAscBy\, \reverse\, \take\, \slice\, and \range\, with support for Avro GenericRecord and Flink Row types. Data conversion is handled by \\#CONV\ with \toJson\, \toJsonOrNull\, and \toJsonString\ for JSON parsing and serialization. Date and time manipulation is available through \\#DATE\ (e.g., \now\, \zone\, \toEpochMilli\, \isBetween\) and \\#DATE\_FORMAT\ (e.g., \parseLocalDate\, \formatter\). Geographic calculations like \distanceInKm\, \midpoint\, \azimuth\, and \closestPointOnLine\ are provided by \\#GEO\. Mathematical operations are exposed via \\#NUMERIC\ (e.g., \toNumber\, \abs\, \sin\, \cos\, \pow\). Random value generation is supported by \\#RANDOM\ (e.g., \nextDouble\, \nextInt\, \nextBoolean\). Finally, \\#UTIL\ provides \uuid\ generation and text \split\ functionality.

utils/default-helpers · high confidence

Users can now select values from a dictionary (key-value list) when configuring node input parameters. This new DictParameterEditor component provides an autocomplete interface that fetches available options from the server, supports searching by typing, and correctly displays the label for previously selected values. It integrates with the existing expression editor framework, handling parsing and validation for dictionary-based inputs.

designer/client/src/components/graph/node-modal/editors/expression/DictParameterEditor · high confidence

The components-api introduces a new annotation-based editor API (Editor, EditorType, Editors) that defines available parameter editors, including new types for JSON templates and multi-select lists. This allows component developers to specify richer input controls, such as multi-select fields with descriptions and groups, directly via annotations on parameters.

components-api/src/main/java/pl/touk/nussknacker/engine/api/editor · high confidence

This change introduces the \EmbeddedDeploymentManager\ for the Lite engine, enabling scenarios to run directly within the application process rather than requiring an external cluster. It supports two distinct modes: streaming (via Kafka) and request-response (via an embedded Pekko HTTP server). The provider registers this manager via the \DeploymentManagerProvider\ service file, and the implementation includes specific deployment strategies for each mode, URL slug sanitization for request-response endpoints, and validation for request-response scenarios.

engine/lite/embeddedDeploymentManager · high confidence

The error boundary module now includes a set of new React components and assets to handle error states with improved UI. This adds a \DefaultFullScreenMessage\ component for full-page error displays, a \NotFound\ component for 404 scenarios, and several context-specific fallbacks: \FullPageErrorBoundaryFallbackComponent\ for general full-page errors, \DialogErrorFallbackComponent\ for errors within window dialogs (including a close button with a countdown timer), \RouteErrorFallbackComponent\ for route-level errors (distinguishing 404s from other errors), \ToolbarErrorFallbackComponent\ for toolbar sections, \TextErrorBoundaryFallbackComponent\ for inline text alerts, and \PlaceholderIconFallbackComponent\ for missing icon states. It also introduces new SVG assets (\error-occurred.svg\, \warning-occurred.svg\, \placeholder-icon.svg\) and centralizes error messages via i18next keys in the main \ErrorBoundary\ component.

designer/client/src/components/common/error-boundary · high confidence

This change introduces a new Command Bar component (powered by the kbar library) that allows users to quickly search for and open nodes within the current scenario, as well as toggle application settings directly from the interface. The feature is gated behind the 'experimental.commandBar' user setting, meaning it is disabled by default and must be explicitly enabled in settings to appear. The implementation includes the core UI components for the search interface, result rendering, and specific hooks to register scenario node commands and settings flags.

designer/client/src/components/CommandBar · high confidence

A new \extensions-api\ module has been introduced to centralize process configuration and expression language settings. This includes Java API classes like \ClassExtractionSettings\ and \ExpressionConfig\ for defining class visibility, member predicates, and expression compilation options, alongside Scala traits such as \ProcessConfigCreator\ and \BaseModelData\ for model initialization. The module also defines core deployment and scenario activity models (e.g., \ScenarioActivity\, \ProcessAction\) and dictionary services (\DictDefinition\, \DictRegistry\), providing a unified interface for model extensions and runtime configuration.

extensions-api · high confidence

The process attachment interface has been rebuilt with new React components (AddAttachment, AttachmentEl) and MUI-based styling. Users can now drag-and-drop or select files to attach to a process node, with the system automatically capturing the current process name and version ID. Attached files are displayed in a list showing the filename and version, with the ability to remove individual attachments via a delete icon.

designer/client/src/components/processAttach · high confidence

The fragment input definition section of the node modal now uses a dedicated set of React components (FieldsRow, FieldsSelect, FragmentInputDefinition, TypeSelect) to manage parameter inputs. This introduces a structured interface for adding, removing, and reordering fragment input parameters, with support for selecting data types via a creatable select dropdown and displaying validation errors directly within the field rows.

designer/client/src/components/graph/node-modal/fragment-input-definition · high confidence

The components-api module introduces a new set of classes to support generic function definitions and improved error reporting. TypingFunction provides an abstract base for defining methods with specific parameter and return type signatures, including support for var-args via MethodTypeInfo and Parameter. To handle validation failures, new error types ExpressionParseError and GenericFunctionTypingError have been added, allowing for detailed error details such as cell errors in tabular data, text ranges, and incompatible parameter definitions. This change enhances the API's ability to provide precise feedback on expression parsing and type checking errors.

components-api/src/main/scala/pl/touk/nussknacker/engine/api/generics · high confidence

The \designer/client/src/components/graph/utils\ directory now contains four new utility modules that enhance the visual editor's interaction and data management. \dragHelpers.ts\ introduces logic to validate drop targets based on node type (e.g., limiting inputs/outputs for Join, Split, or Filter nodes) and calculates coverage ratios for drag-over highlighting. \fragmentSchemaAligner.ts\ provides a mechanism to synchronize fragment input parameters with their source definitions, addressing edge cases where fragments are moved between groups or when definitions change externally. \graphUtils.ts\ expands graph manipulation capabilities with functions to map node/edge changes, clean up input edges, replace output edges, delete nodes while adjusting branch parameters, and inject new nodes into existing connections, alongside a touch/mouse event handler. Finally, \stickyNotesUtils.ts\ implements support for sticky notes by defining their component structure and providing functions to merge them with the node list for frontend rendering and extract them for backend persistence.

designer/client/src/components/graph/utils · high confidence

Added four new helper modules to support touch-device interactions and performance optimization: \detectDevice.ts\ provides functions to identify touch screens and touch events; \ArrayKeyedMapLike.ts\ implements a map structure supporting array keys; \CacheWithTTL.ts\ offers a cache with time-to-live and size limits; and \memoizeByArgsWithTTL.ts\ integrates these into a memoization utility with expiration capabilities.

designer/client/src/helpers · high confidence

The \utils/utils-internal\ module now includes a comprehensive set of internal utilities to support the engine's runtime and configuration. This includes factories for creating \ModelClassLoader\ and \DeploymentManagersClassLoader\ with support for nested directory expansion and relative path resolution, as well as a \ScalaServiceLoader\ for robust service discovery. The module introduces process listeners (\LoggingListener\, \EndCountingListener\, \ExceptionCountingListener\, \NodeCountingListener\) that provide detailed runtime metrics and logging for node execution, errors, and dead ends. Additionally, it adds a \SensitiveDataMasker\ for obfuscating sensitive data in logs and JSON, and various configuration helpers like \ConfigFactoryExt\ and \ScalaMajorVersionConfig\.

utils/utils-internal · high confidence

The listener-api module now exposes a new set of traits and case classes to handle scenario lifecycle events and metadata. \ProcessChangeListener\ and \ProcessChangeListenerFactory\ provide the interface for registering and creating listeners, while \ProcessChangeEvent\ defines specific events such as \OnSaved\, \OnRenamed\, \OnArchived\, \OnDeleted\, \OnActionSuccess\, \OnActionFailed\, and \OnActionExecutionFinished\. The \OnActionExecutionFinished\ event now includes an \actionId\ field. Additionally, \ListenerScenarioWithDetails\ provides a unified interface for accessing scenario metadata, including \scenarioLabels\, \scenarioGraph\, and version history.

designer/listener-api/src/main/scala/pl/touk/nussknacker/ui/listener · high confidence

The live data container now includes a new component, LiveDataThroughputs, which renders real-time throughput animations on the process graph. This feature visualizes node and transition activity using CSS animations and heatmap-style coloring for links, with performance driven by user settings to toggle transition and node animations. Supporting utilities handle data event filtering, animation state management, and color interpolation, while a new hook automatically starts or stops the live data stream based on scenario state and user preferences.

designer/client/src/containers/liveData · high confidence

The Designer now includes a set of shell scripts (buildClient.sh, buildServer.sh, runServer.sh, etc.) to streamline local development. These scripts automate the build process, configure environment variables for local execution (such as Flink and Kafka endpoints), and support features like remote debugging and Docker-based environment usage, making it easier for developers to run and test the Designer locally.

designer · high confidence

The metrics module now exposes gauges for the total number of scenarios, deployed scenarios, and fragments, with a configurable cache duration to reduce repository load. Additionally, a new utility is available to measure and record the execution time of asynchronous operations via Dropwizard timers.

designer/server/src/main/scala/pl/touk/nussknacker/ui/metrics · high confidence

The designer now includes a suite of new modal dialogs to handle specific user workflows: adding and modifying comments and attachments, comparing scenario versions, deploying processes with optional warnings, generating and testing test data, saving scenarios as test cases, and viewing detailed scenario properties. These components standardize the UI using MUI and the window manager, providing consistent validation, loading states, and confirmation flows for these core designer actions.

designer/client/src/components/modals · high confidence

The Group By configuration in the aggregate node modal now supports multiple SpEL expressions. Users can add, edit, and remove several values, which are displayed as individual chips with syntax highlighting. The editor allows entering new expressions by pressing Enter and provides validation feedback for each value.

designer/client/src/components/graph/node-modal/aggregate/groupBy · high confidence

The node modal now includes dedicated UI components for interacting with node actions directly. Users can generate new endpoints via the GenerateNewEndpoint button, which validates node data and handles the resulting topic. A SendRequestButton allows sending sample HTTP requests to the node. Additionally, a TestConnectionButton enables testing WebSocket forwarder connections, displaying success or error messages with optional first message details. These components are styled with a consistent loading state indicator and integrated into the node action buttons area.

designer/client/src/components/graph/node-modal/node-action-buttons · high confidence

This change introduces a new set of components and utilities within the node-modal editors directory to support flexible field editing and validation. It adds EditableEditor and EditableEditorRow to handle expression-based inputs with switchable editor types, alongside supporting infrastructure like ParamKeyProvider for parameter context, RenderFieldLabel for consistent label rendering, and a styled FormControl wrapper. It also introduces a new Validators module defining specific validation rules (mandatory, unique, integer, range) and error handling logic, as well as types.ts for parameter configuration. These files collectively provide the UI and logic foundation for validating and editing node parameters in the designer.

designer/client/src/components/graph/node-modal/editors · high confidence

The designer server now includes a complete backend system for managing periodic (scheduled) scenarios. This change introduces a new \PeriodicDeploymentManager\ that wraps existing deployment managers to handle cron-based execution, including a \PeriodicProcessService\ for scheduling logic and a \SlickPeriodicProcessesRepository\ for persisting schedule data. High availability is supported via a \PeriodicDeploymentLock\ that can operate in dedicated or leader-based modes, ensuring only one node executes scheduled deployments. The system uses Pekko actors (\DeploymentActor\ and \RescheduleFinishedActor\) to poll for and execute scheduled runs, while \PeriodicProcessStateDefinitionManager\ and \PeriodicStateStatus\ provide the necessary UI state definitions (e.g., 'Scheduled', 'Waiting for reschedule') and action tooltips for these processes.

designer/server/src/main/scala/pl/touk/nussknacker/ui/process/periodic · high confidence

The designer now features a new AddProcessDialog and AddProcessForm that allow users to create processes by selecting a processing mode (Streaming, Request-response, or Batch), a category, and a process engine. The dialog includes validation for the process name and engine setup, and displays a contact support message when the Batch processing mode is selected but not available to the user.

designer/client/src/components · high confidence

The designer server introduces a new repository layer for managing scenarios and their lifecycle events. This includes a new ActivityService that records deployment activities, a DBFetchingProcessRepository for querying scenario details, and a ProcessRepository for creating and updating scenarios. The change also adds support for tracking scenario activities via a new ScenarioActivityRepository and updates the PeriodicProcessesRepository to handle periodic process deployments. These changes provide a more structured and auditable way to manage scenario data and actions within the system.

designer/server/src/main/scala/pl/touk/nussknacker/ui/process/repository · high confidence

The properties panel now uses a new set of components (NameField, PropertiesForm, PropertiesFormFields, ScenarioProperty) to render and edit node properties. This introduces a structured form layout that displays the node name, dynamically renders scenario-specific properties based on configuration, and includes a description field and a toggle for showing descriptions. The implementation leverages existing editor infrastructure (EditableEditor, FieldLabelProvider) and validation logic, providing a consistent UI for property editing within the node details modal.

designer/client/src/components/properties · high confidence

A new \DndItems\ component has been added to the common library, providing a reusable interface for reordering lists of items via drag-and-drop. It leverages \@hello-pangea/dnd\ and MUI to render draggable items with a visual handle, supporting callbacks for item movement and destination tracking. The implementation includes supporting components like \DragHandle\ for the grab UI, \DropTarget\ to manage the drag context, and \FakeFormWindow\ to style the dragged clone, enabling consistent reordering behavior across different designer surfaces.

designer/client/src/components/common/dndItems · high confidence

The components-api module now includes new exception classes to support runtime parameter validation. A \NonTransientException\ class has been added to represent errors that do not require retry, carrying input data, a message, and a timestamp. A \ParameterRuntimeValidationException\ extends this to specifically handle validation failures for individual parameters, storing the parameter name and input context. Additionally, a \NuExceptionInfo\ case class and companion object have been introduced to aggregate exception details, including node component information, the unwrapped throwable, execution context, and input data, providing a structured way to capture and report exception context.

components-api/src/main/scala/pl/touk/nussknacker/engine/api/exception · high confidence

The build system now includes several new sbt plugins to automate development workflows. A pre-commit hook automatically formats staged Scala files and checks for explicit SQL schema usage in the designer module before commits. Additionally, the build automatically configures Git paths for hooks and blame ignore files, and provides a task to generate Nu Designer OpenAPI documentation. The build environment has also been upgraded to sbt 1.12.4 with updated plugins like sbt-assembly and sbt-scalafmt.

project · high confidence

This change introduces a suite of new utility classes and traits within the designer server's \ui.util\ package to support core platform capabilities. It adds \ApiAdapter\ and \ApiAdapterService\ to enable versioned data migration between environments, \ScenarioGraphComparator\ to detect and describe meaningful differences between scenario graphs (including nodes, edges, and sticky notes), and \PdfExporter\ to generate PDF reports of scenarios with activity logs. Additionally, it provides \CorsSupport\ and \SecurityHeadersSupport\ for HTTP header management, \MultipartUtils\ and \IOToFutureSttpBackendConverter\ for request handling, and various helper objects like \LoggedUserUtils\ and \ScenarioActivityUtils\ to streamline user and activity data processing.

designer/server/src/main/scala/pl/touk/nussknacker/ui/util · high confidence

The designer client now includes a new \common\ directory containing a suite of shared utilities to standardize functionality across the application. This includes robust clipboard handling with fallbacks for HTTP contexts, a secure \CodeBlock\ component that sanitizes passwords and supports syntax highlighting via Ace Editor, and a \PendingPromise\ class for managing asynchronous token retrieval. Additionally, the update introduces utilities for managing user authentication and authorization headers, processing and validating scenario definitions, handling test result data, and formatting dates and URLs.

designer/client/src/common · high confidence

Added a new Spinner component and a SpinnerWrapper component to the designer client. The Spinner component renders a dual-layer circular progress indicator (determinate and indeterminate) centered on the screen using MUI's CircularProgress and Box components, styled with theme colors. The SpinnerWrapper component accepts an isReady prop and conditionally renders its children or the Spinner, providing a reusable pattern for displaying loading states while content is being prepared.

designer/client/src/components/spinner · high confidence

A new Survey toolbar panel has been added to the designer interface. This component displays a user-configurable survey message with 'OK' and 'Close' actions, allowing users to acknowledge or dismiss the prompt. The dismissal state is persisted via user settings, ensuring the survey is not shown again once closed.

designer/client/src/components/toolbars · high confidence

The code editor now supports syntax highlighting for JSON templates, SpEL templates, plain text, and SQL. JSON templates inherit JSON rules but allow SpEL expressions (\#{...}) inside keys and string values. SpEL templates provide basic text highlighting with SpEL expression support. SQL highlighting includes keywords, functions, data types, and supports SpEL expressions within strings and aliases.

designer/client/src/brace/mode · high confidence

The table component area now includes two new files: AddProcessButton.tsx and SearchFilter.tsx. AddProcessButton.tsx provides a hook to configure a button that opens either a 'Create new scenario' or 'Create new fragment' window, depending on the isFragment flag, using the window manager. SearchFilter.tsx introduces styled SVG icons for advanced search, standard search, and clear actions, utilizing MUI's styled API for theming and interaction states.

designer/client/src/components/table · high confidence

The table editor in the node-modal now features a context menu for deleting rows and columns and resetting column widths, supports date picker cells for java.time types, and displays validation errors with dashed highlights and tooltips directly in the grid.

designer/client/src/components/graph/node-modal/editors/expression/Table · high confidence

This change introduces the core server-side implementation for the test case assertion framework. It adds the \AssertionVerifier\ and \AssertionsCompiler\ to validate and execute assertions (including equality, comparison, size, contains, and matches) against scenario node results, returning structured \AssertionResult\ objects. It also includes \EnricherMockGenerator\ and \ExpressionGenerator\ to automatically generate SpEL mock expressions for enricher outputs based on type information, and provides \TestsFunctions\ (exposed as the \TESTS\ global variable) to allow users to write assertion logic directly in their test cases.

designer/server/src/main/scala/pl/touk/nussknacker/ui/process/test/testcase · high confidence

This change introduces a new set of React components for the test toolbar located in \designer/client/src/components/toolbars/test/buttons\. It adds specific buttons for Ad-hoc testing, running tests from a file, generating test data, and executing scenario tests (including support for multiple test cases and presets). It also includes buttons for Live Data toggling, displaying process counts, and hiding test details. Additionally, it provides a shared \ButtonProgress\ component for visual feedback and a \useProgress\ hook to manage countdown timers for data refreshes.

designer/client/src/components/toolbars/test/buttons · high confidence

The \utils/test-utils\ module now includes a comprehensive set of new Scala test helpers and configuration files to support integration testing. This adds a \DockerBasedInstallationExampleEnvironment\ that spins up the Nussknacker stack (Designer, Kafka, Schema Registry) via Docker Compose, along with a \bootstrap-setup.override.yml\ to configure the example scenarios library. The module also introduces REST-assured extensions (\NuRestAssureExtensions\, \NuRestAssureMatchers\) for JSON validation and request building, patient ScalaFutures traits (\PatientScalaFutures\, \VeryPatientScalaFutures\) for handling async timeouts, and utilities for managing Docker containers, ports, and classloaders during tests.

utils/test-utils · high confidence

The TestingContentElements directory now contains the UI components that power the Testing tab in the node details modal. Users can define assertions with multiple operators (equals, notEquals, greaterThan, lessThan, hasSize, contains, matches) and optional descriptions, view pass/fail status, and use an expression builder with a \#records hint for the Actual field. Mocking is controlled via a per-node switch and an expression field that can auto-generate default mock expressions. Test data input is managed through a table supporting add, paste, copy, and append-from-live-data actions, with limit-exceeded warnings. These components handle the local state, validation, and dispatch to the Redux store for assertions and test records.

designer/client/src/components/graph/node-modal/node/NodeContent/TestingContentElements · high confidence

The designer client now includes a new set of themed input components (InputWithIcon, SearchInputWithIcon, and ThemedInput) to standardize text input styling and behavior. These components provide consistent theming via MUI, support icon adornments for search fields, and expose focus management capabilities to improve keyboard navigation and user interaction within the designer interface.

designer/client/src/components/themed · high confidence

The toolbar settings component now supports a new configuration-driven architecture that allows for horizontal button toolbars. This change introduces a new \HorizontalButtonsToolbar\ component that renders buttons in a row with a distinct visual style (backdrop blur, specific padding, and shadow effects). The \ToolbarSelector\ and \getToolbarComponent\ utilities have been updated to handle both vertical and horizontal toolbar variants, enabling the system to dynamically render different toolbar layouts based on configuration. Additionally, the \useToolbarConfig\ hook has been enhanced to parse and deduplicate toolbar configurations from the Redux store, ensuring that toolbars can be correctly identified and rendered in their respective positions.

designer/client/src/components/toolbarSettings · high confidence

The security module introduces a new \AuthenticationProvider\ SPI and \AuthManager\ to centralize authentication logic, supporting Basic, OAuth2, OIDC, and Dummy strategies via service loading. A key addition is the impersonation mechanism, allowing authenticated users to act as other identities via the \Nu-Impersonate-User-Identity\ header, with strict permission checks enforced by the new \LoggedUser\ and \RulesSet\ classes. The implementation also adds \AnonymousAccessSupport\ for optional anonymous roles and \FrontendStrategySettings\ to expose authentication configuration to the UI.

security · high confidence

Added AssignabilityUtil to safely check if a class is assignable to another using a string reference and the current thread's context class loader, avoiding hard dependencies on specific libraries. Also added IdToTitleConverter to transform component IDs into human-readable titles by replacing hyphens with spaces and capitalizing words, enforcing a consistent naming convention for display purposes.

components-api/src/main/scala/pl/touk/nussknacker/engine/util · high confidence

The utils/utils module now includes a collection of new utility components to support engine operations. Configuration handling is enhanced with CustomFicusInstances, which extends Ficus to support UUID parsing and defaults relative URLs to the file scheme, alongside a ResourceLoader for file and classpath access. A new caching layer (DefaultCache) is introduced, backed by Caffeine, supporting configurable access and write expiry policies. Number conversion logic is standardized via a new NumberUtils class and a BigDecimalScaleEnsurer to ensure consistent precision in SpEL arithmetic. Additional utilities include a round-robin list merger, safe lazy value caching, and synchronous execution contexts for Cats Effect.

utils/utils · high confidence

The components-api module now includes new annotations to support runtime parameter validation, specifically targeting duration fields and custom validators. Users can now annotate parameters with @NonNegativeDuration and @PositiveDuration to enforce duration constraints, with a configurable ValidatorMode (AUTO, COMPILE\_TIME, or COMPILE\_TIME\_AND\_RUNTIME) to control when validation occurs. Additionally, @CustomValidator allows attaching specific CustomParameterValidator implementations to parameters, while @CompileTimeEvaluableValue and @JsonValidator provide markers for compile-time evaluation and JSON-specific validation contexts respectively.

components-api/src/main/java/pl/touk/nussknacker/engine/api/validation · high confidence

Added two new configuration files in the designer client: \simpleScriptPlugin.ts\ and \withModuleFederationPlugins.ts\. The \SimpleScriptPlugin\ allows running arbitrary shell scripts (such as cleaning and generating federated types) during the webpack emit phase, with support for Windows environments. The \withModuleFederationPlugins.ts\ file configures Webpack's Module Federation Plugin, integrating the new script plugin to handle federated type generation and packaging, and sets up remote module loading with hash-based cache busting.

designer/client/configs · high confidence

The node details modal has been restructured to include a 'Testing' tab alongside the existing 'General' tab. This new tab dynamically renders testing-specific controls based on the node type: Source nodes display input data records, while Enricher nodes (excluding decision-tables) can show mock response settings and assertions if the user setting 'showMockFieldOnEnrichers' is enabled. All other node types default to showing assertions. The tab interface persists the active tab selection in the URL query parameter and displays error indicators on tab labels when validation errors are present.

designer/client/src/components/graph/node-modal/node/NodeContent · high confidence

The statistics module now persists a unique application fingerprint in the database. A new FingerprintRepository implementation manages this data, allowing the system to read an existing fingerprint or save a new one if none is present, ensuring consistent identification across deployments.

designer/server/src/main/scala/pl/touk/nussknacker/ui/statistics/repository · high confidence

The application now allows processing type configurations to be reloaded at runtime without requiring a full restart. A new \ReloadableProcessingTypeDataProvider\ manages this state, ensuring that updates are applied atomically with automatic rollback to the previous state if the reload process fails, while also properly closing and cleaning up resources from the old configuration.

designer/server/src/main/scala/pl/touk/nussknacker/ui/process/processingtype/provider · high confidence

The repository is initialized with the Apache License 2.0, a Privacy Policy, and a comprehensive README describing the Nussknacker low-code platform for real-time decision algorithms. Developer experience is established through an .editorconfig, .gitignore, .sdkmanrc (Java 17), and an sbt wrapper script. Build and code quality are configured via .scalafmt.conf (Scala 2.13, 120-char limit), .scalafix.conf (Slick schema enforcement), and a .git-blame-ignore-revs file to exclude bulk formatting commits. CI support is provided by shell scripts for running sbt and checking staged backend files.

(repo-wide) · high confidence

The graph editor now supports pinch-to-zoom and multi-node selection on touchscreens, introduces a new sticky note element for annotations, and adds a hover-based description popover for nodes. These changes are implemented via new components (GlobalCursor, PanZoomPlugin, RangeSelectPlugin, StickyNoteElement) and a refactored Graph class, improving usability on tablets and touch devices.

designer/client/src/components/graph · high confidence

The Testing Data Records modal in the node details view has been completely redesigned to use a new grid-based table interface. This update introduces several new capabilities for managing test data: users can now append records from live data sources via a dedicated button, paste JSON records (supporting single objects, arrays, and NDJSON formats) through a new dialog, and edit input variables directly within the table cells using a JSON editor with validation. The table also supports row reordering, selection, and deletion, while enforcing configurable limits on the number of testing records.

designer/client/src/components/modals/TestingDataRecords · high confidence

The Kafka component is now explicitly registered for the Flink engine through a Service Provider Interface (SPI) configuration. A new \FlinkKafkaComponentProvider\ class has been added to handle component definition creation, delegating to the shared \BaseFlinkKafkaComponentProvider\ while specifying the provider name as "kafka". This ensures the Flink engine correctly discovers and initializes Kafka-related components during execution.

engine/flink/components/kafka · high confidence

The designer now records user interactions with scenario comments and attachments as structured activity log entries. Users can add, edit, and delete comments, as well as upload and remove file attachments, with these actions persisted in the database and decorated with audit logging for compliance and history.

designer/server/src/main/scala/pl/touk/nussknacker/ui/process/repository/activities · high confidence

The Designer server now allows users to expose custom HTTP services through a new plugin mechanism. The server loads custom service providers via the Scala ServiceLoader and supports two integration styles: Pekko-based routes (for legacy Akka HTTP compatibility) and Tapir-based endpoints (for the new API layer). These custom services are mounted under the /api/custom/{name} path prefix, with authentication applied consistently with other API routes. The implementation includes a new HTTP server interpreter to handle Tapir endpoints on top of Pekko HTTP, custom error handling for missing authorization headers, and stream body support for file uploads via InputStream codecs.

designer/server/src/main/scala/pl/touk/nussknacker/ui/server · high confidence

The Request-Response runtime now includes a bundled Swagger UI interface, allowing users to view and interact with the API definition directly via the embedded web assets (HTML, CSS, JS) located in the runtime resources.

engine/lite/request-response/runtime · high confidence

The Flink engine now provides a unified Kafka component implementation that supports both Avro and JSON schemas through a single 'kafka' source and sink. This change introduces a universal serialization and deserialization layer backed by the Schema Registry, allowing scenarios to read and write events with schema evolution handling (e.g., converting between compatible Avro versions) without needing separate component types for different formats. The implementation includes a new \FlinkKafkaUniversalSink\ that utilizes Flink's Sink2 API and a \BaseFlinkKafkaComponentProvider\ to register these components, simplifying configuration and enabling consistent behavior across schema-based Kafka interactions.

engine/flink/schemed-kafka-components-utils · high confidence

The assertion designer now displays pass/fail status directly on workflow nodes. A new component reads active test case results and renders a colored badge (green for pass, red for failure) on each node, showing the ratio of passed to total assertions. This provides immediate visual feedback on test outcomes within the graph view without needing to open a separate results panel.

designer/client/src/containers/assertions · high confidence

The \components-api\ module now includes a new set of types for defining node transformations, specifically \BaseDefinedParameter\, \DynamicComponent\, \NodeDependencyValue\, and \WithStaticParameters\. These changes introduce a structured way to handle defined parameters (lazy, eager, branch, and failed states) and provide a generic interface for dynamic components that can define parameter lists and validation contexts based on current inputs. This refactors the internal API to support more flexible and type-safe component definitions within the scenario editor.

components-api/src/main/scala/pl/touk/nussknacker/engine/api/context/transformation · high confidence

The Designer API now includes formal Tapir endpoint descriptions for several core services, enabling consistent API documentation and client generation. This change introduces endpoint definitions for retrieving action parameters, application health and build info, deployment execution and status, dictionary lookups, scenario migration between environments, node validation and additional info, notifications, scenario labels, scenario parameter combinations, and usage statistics.

designer/server/src/main/scala/pl/touk/nussknacker/ui/api/description · high confidence

The system introduces a new API layer for loading processing type configurations, defined by the \ProcessingTypeConfigsLoader\ trait and its factory. This allows the application to dynamically load configuration maps keyed by processing type, supporting scenarios where configuration is derived from designer settings or external sources via the provided \SttpBackend\ and \Config\ inputs.

designer/config-loader-api · high confidence

The Kafka-related utilities have been extracted into the new \utils/kafka-components-utils\ module, consolidating shared code previously scattered across the codebase. This includes the \CachedTopicsExistenceValidator\ for validating Kafka topic existence with caching, serialization helpers like \KafkaProducerHelper\ and \CharSequenceSerializer\, and source metadata handling via \InputMeta\ and \KafkaContextInitializer\. The module also introduces \KafkaFactory\ for standard parameter names and \KafkaComponentsConfig\ for configuration parsing, providing a centralized foundation for Kafka integration.

utils/kafka-components-utils · high confidence

The designer client now uses a dedicated HttpService module to manage all API interactions. This change consolidates HTTP logic into a single entry point, providing a unified interface for fetching scenarios, process definitions, components, and user settings, as well as handling health checks and backend notifications. By centralizing these requests, the client ensures consistent error handling and data transformation across the application.

designer/client/src/http/HttpService · high confidence

The streaming-lite runtime implementation has been extracted from the base engine into a dedicated \engine/lite/runtime\ module. This change introduces the core Lite interpreter (\RunnableScenarioInterpreter\), the test runner (\TestRunner\), and the metrics infrastructure (Dropwizard, InfluxDB, JMX reporters) into this new location, establishing the runtime foundation for the Lite engine.

engine/lite/runtime · high confidence

The designer submodule now includes dedicated configuration files for its build and serving infrastructure. This adds an Nginx setup (default.conf and gzip.conf) to handle static file serving, compression, and base-href rewriting for proxied environments. It also introduces a comprehensive Webpack configuration (common, dev, and prod modes) that manages asset processing (SVG, images, CSS), environment variable injection, and source maps. Additionally, the diff introduces Module Federation support via a custom plugin wrapper and a SimpleScriptPlugin for build-time script execution, enabling the designer to act as a federated remote or host within the larger application architecture.

designer/submodules/configs · high confidence

The client-side state management in the designer has been restructured to use a new modular reducer system. This change introduces dedicated reducers for specific domains including cloud data, HTTP error handling, node details, process activity, scenario drafts, and user settings, all combined into a new root reducer. It also adds utility functions for merging reducers and managing layout state, alongside a new utility for waiting on window values, replacing the previous monolithic or less-structured state approach.

designer/client/src/reducers · high confidence

The Redux action logic for the designer client has been reorganized into a new directory structure under \designer/client/src/actions/nk\. This change introduces dedicated modules for specific concerns, including \abortControllersStack\ for managing request cancellation, \liveData\ for real-time data streaming, \editNode\ and \node\ for graph manipulation, \adhocTesting\ for validation, and \process\ for scenario lifecycle management. This restructuring separates concerns and improves maintainability of the client-side state management.

designer/client/src/actions/nk · high confidence

The Redux selectors in the designer client have been reorganized from a monolithic structure into a modular directory of specialized files (e.g., \graph.ts\, \testing.ts\, \toolbars.ts\). This change improves code maintainability and performance by using \reselect\ to create fine-grained, memoized selectors for specific domains like scenario state, testing results, and UI configuration, ensuring that components only re-render when the specific data they depend on actually changes.

designer/client/src/reducers/selectors · high confidence

The application startup logic has been restructured into distinct factory classes (InfrastructureServices, DomainServices, and NussknackerAppFactory) to improve modularity and separation of concerns. This change consolidates the initialization of infrastructure components (such as the ActorSystem, database references, and HTTP backends) and domain services (including process repositories, deployment managers, and reconciliation logic) into a cleaner, resource-managed flow. Users benefit from a more robust initialization process that better supports high-availability modes and deployment recovery, as the new structure explicitly handles leadership acquisition and service lifecycle management.

designer/server/src/main/scala/pl/touk/nussknacker/ui/factory · high confidence

The repository now includes a new .husky/post-checkout hook that delegates to per-repo private scripts located in \~/.config/git-hooks/\<repo\>/post-checkout.d/, allowing for custom logic to run after checkout events. Additionally, the .husky/pre-commit hook has been updated to specifically check for staged changes in the designer/ (client and submodules) and backend (.scala, .sbt) directories, triggering respective validation scripts only when relevant files are modified.

.husky · high confidence

The application initialization process now performs automatic migrations on existing processes when the application starts. This is handled by the new \Initialization\ module, which runs an \AutomaticMigration\ operation that fetches all unarchived processes and applies necessary model updates via registered \ProcessModelMigrator\ instances. This ensures that process definitions are kept up-to-date with the current schema or model version without requiring manual intervention.

designer/server/src/main/scala/pl/touk/nussknacker/ui/initialization · high confidence

The system now includes a suite of automatic migrations that update legacy process definitions to match current component standards. This ensures backward compatibility by handling several key changes: renaming the 'periodic' source to 'event-generator' and its 'period' parameter to 'schedule'; converting 'split' nodes to 'for-each' with updated parameter names; migrating 'union' nodes to use 'Output expression' instead of 'value'; updating 'Decision Table' and 'Previous Value' component parameter labels; adding named outputs to custom nodes; converting node IDs to UUIDs; and migrating SpEL string literals to SpelTemplate expressions. These changes allow older processes to run correctly without manual intervention.

defaultModel/src/main/scala/pl/touk/nussknacker/defaultmodel/migrations · high confidence

The Designer now periodically synchronizes deployment statuses with the underlying processing engines in the background. A new scheduler runs a synchronizer that checks deployments in non-final states (Canceled, Finished, Problem) and updates their status in the database based on the actual engine state. This ensures that the UI reflects the true status of running or recently completed deployments without requiring manual refresh, and the process is safe for High Availability setups by only running on the leader node.

designer/server/src/main/scala/pl/touk/nussknacker/ui/process/newdeployment/synchronize · high confidence

The system now uses a new ModelConfig class to centralize settings that were previously handled by ProcessObjectDependencies. This change introduces configurable options for allowing scenarios to end without a sink, switching the default input method for JSON-like values from dynamic forms to a single JSON template parameter, and defining default editors for string-type parameters. It also adds support for configuring live data preview features, including retention time, throughput windows, and storage backends (Designer JVM or Designer DB).

components-api/src/main/scala/pl/touk/nussknacker/engine · high confidence

Users can now have cron expressions for periodic jobs validated at compile time and properly extracted from the process definition. A new CronParameterValidator ensures that only valid cron syntax (e.g., '0 \* \* \* \* ? \*') is accepted, providing clear error messages for invalid inputs. Additionally, a CronSchedulePropertyExtractor handles the conversion of cron schedule properties into the internal API format, ensuring consistent handling of single and multiple cron schedules within the main Nu DB.

designer/server/src/main/scala/pl/touk/nussknacker/ui/process/periodic/cron · high confidence

The database migration system has been updated to support explicit schema names, ensuring that Slick tables and plain SQL queries target the correct schema rather than relying on defaults. Additionally, a new connection wrapper ensures that database connections used during migrations are not closed prematurely, providing a stable environment for schema updates. These changes improve reliability for deployments using non-default schemas.

designer/server/src/main/scala/pl/touk/nussknacker/ui/db/migration · high confidence

This update introduces a series of database migrations that add new tables and transform existing process definitions to support recent platform capabilities. New tables are created to store scenario activities (V1\_056), sticky notes (V1\_060), and periodic scenario deployments (V1\_061). Existing process JSON structures are migrated to reflect internal refactors: subprocesses are renamed to fragments (V1\_046), standalone process definitions are converted to request-response definitions (V1\_032), and source/sink exception handler expressions are updated to use a new parameter format (V1\_019). Additionally, component usage caches are invalidated (InvalidateComponentsUsagesCache), and metadata fields such as group nodes (V1\_013) and spill state to disk (V1\_030) are adjusted to align with the current data model.

designer/server/src/main/scala/db/migration · high confidence

The designer's database layer has been refactored to use explicit Slick schema enforcement (via \apiWithEnforcedSchema\), ensuring stricter type safety for columns. This change introduces new database tables and entity definitions to support enhanced scenario management: \scenario\_activities\ tracks detailed lifecycle events (creation, deployment, modification, etc.) with impersonation metadata; \scenario\_labels\ and \tags\ provide categorization for scenarios; \process\_attachments\ stores file attachments linked to process versions; \fingerprints\ stores unique identifiers; \live\_data\ supports real-time data monitoring; and \scheduled\_scenarios\ / \scheduled\_scenario\_deployments\ manage periodic process execution. The \process\_versions\ table now also stores component usage metadata alongside the scenario JSON.

designer/server/src/main/scala/pl/touk/nussknacker/ui/db/entity · high confidence

The table editor now correctly handles the visibility and positioning of the date picker component. A new DatePicker cell type has been introduced to manage date inputs, ensuring the picker popup appears in the correct location relative to the grid cell, even when space is limited or the cell is near the viewport edge.

designer/client/src/components/graph/node-modal/editors/expression/Table/customCells · high confidence

The deployment manager API has been restructured to use a sealed trait \DMScenarioCommand\ for all deployment actions (such as validation, running, canceling, stopping, testing, and running off-schedule), replacing previous method-based interfaces. A new \DeploymentStatus\ sealed trait defines specific states like \Running\, \Finished\, \Canceled\, and \Problem\, while \ProcessStateDefinitionManager\ and \OverridingProcessStateDefinitionManager\ provide a standardized way to define status properties (icons, tooltips, descriptions) and allowed actions. The API also introduces \DeploymentUpdateStrategy\ for handling state restoration during updates, \DataFreshnessPolicy\ for caching status queries, and dedicated support traits for scheduling, live data preview, and deployment synchronization.

designer/deployment-manager-api/src/main/scala/pl/touk/nussknacker/engine/api/deployment · high confidence

The deployment manager creation process has been refactored to improve reliability and configurability. The \DeploymentManagerProvider\ interface now returns a \ValidatedNel\[String, DeploymentManager\]\ instead of a raw \DeploymentManager\, allowing providers to return specific validation errors during initialization rather than throwing exceptions. Additionally, a new \DeploymentManagerDependencies\ class centralizes shared infrastructure (execution context, I/O runtime, Actor system, HTTP client), and providers can now configure job recovery behavior via \JobsRecoverySettings\, enabling scenarios to automatically recover jobs on startup if desired.

designer/deployment-manager-api/src/main/scala/pl/touk/nussknacker/engine · high confidence

The designer client's theme system has been rewritten to use Material UI (MUI), introducing a new \nuTheme\ and \NuThemeProvider\ that manage light and dark palette modes (defaulting to dark). This change brings a comprehensive set of visual updates: distinct color palettes for primary, secondary, and status colors; specific fill colors for workflow nodes (e.g., Source, Sink, Filter) to improve visual identification; and tailored styles for code editors (Ace) and JSON trees. The theme also includes helper functions for dynamic border colors and extends MUI components like \MuiAlert\ and \MuiSwitch\ with custom styling.

designer/client/src/containers/theme · high confidence

The designer client directory has been reorganized to include a comprehensive set of configuration files that standardize the development environment and tooling. This includes explicit ESLint and Prettier configurations to enforce code style, import ordering, and type-safety rules (such as banning wildcard imports and requiring type-only imports), alongside a new \.nvmrc\ pinning the Node.js version to LTS Iron (20.x). The change also introduces dedicated configuration for testing (Jest, Cypress, and Tstyche), build tooling (Webpack, Babel, SVGO), and module federation, providing a self-contained setup for building, linting, and running the designer client.

designer/client · high confidence

The Designer server's configuration layer has been reorganized into a new package structure, introducing a centralized \DesignerConfig\ that aggregates settings for multiple capabilities. This update adds configuration support for sticky notes, scenario labels with validation rules, and multiple test case execution. It also introduces settings for usage statistics reporting, error reporting toggles, and component links with permission-based availability. Additionally, the system now supports configurable attachment size limits, assistant features, and high availability modes, all loaded via a new \DesignerConfigLoader\ that handles environment variable resolution and fallback defaults.

designer/server/src/main/scala/pl/touk/nussknacker/ui/config · high confidence

The Designer server's database schema has been updated with a series of migrations that introduce new capabilities and refine existing data structures. Key changes include the addition of an 'environments' table, support for scenario labels and fragments (renamed from subprocesses), and the storage of component usages within process versions. Deployment tracking has been enhanced with a dedicated 'deployments' table featuring detailed status fields (e.g., DURING\_DEPLOY, RUNNING, PROBLEM) and a 'process\_actions' table that tracks action states (IN\_PROGRESS, FINISHED, FAILED) with failure messages. The schema also now supports scheduled scenarios with resolved JSON storage, impersonation identity tracking across processes and actions, and a 'live\_data' table for real-time scenario data. Additionally, integrity improvements include cascading deletes, unique name constraints on processes, and data fixes for line breaks in activity properties.

designer/server/src/main/resources/db · high confidence

The statistics reporting mechanism now encrypts collected usage data before transmission to protect user privacy. The system generates a unique fingerprint to identify instances and combines various metrics (scenario counts, component usage, activity stats) into a single payload. To comply with URL length limits, this payload is split into chunks and each chunk is encrypted using a hybrid RSA-AES scheme before being sent to the statistics endpoint.

designer/server/src/main/scala/pl/touk/nussknacker/ui/statistics · high confidence

A new Scalafix rule has been added to the \scalafix-rules\ module to detect and flag Slick \Table\ definitions and plain SQL interpolators (\sql\, \sqlu\, \tsql\) that lack explicit schema qualifiers. This change supports the migration toward explicit schema names in database access, ensuring that table references and SQL statements use qualified names (e.g., \my\_schema.users\) rather than relying on default schemas or search paths. The rule includes a utility detector to analyze SQL tokens for unqualified object references and excludes specific files like \DbRef.scala\ from enforcement.

scalafix-rules · high confidence

The REST model now returns more detailed information in the responses for creating and updating processes. Creating a scenario now returns the process ID, version ID, and name in the CreateScenarioResponse. Updating a scenario via PUT now includes the validation errors, warnings, node typing data, node names, and the new version ID in the UpdateScenarioResponse, providing users with comprehensive feedback on the operation's outcome.

designer/restmodel/src/main/scala/pl/touk/nussknacker/restmodel/process · high confidence

The scenario compiler now provides more precise error reporting and improved type conversion for SpEL expressions. Parsing now tracks exact text ranges for expressions and sub-expressions, enabling accurate error location highlighting in templates. Collection operations (projections and selections) now support Maps by exposing entry keys and values, and custom converters allow automatic conversion of Flink Row and Avro IndexedRecord objects to Maps for easier access. Additionally, a custom reflection helper optimizes argument conversion for method invocations.

scenario-compiler · high confidence

The scenario actions toolbar now provides more detailed status information for running scenarios. A new ScenarioState component displays the current process state icon and, when a scenario is actively running, shows the specific running version number and the time it started. This information is only visible for full scenarios, not for fragments, ensuring the toolbar remains uncluttered for simpler use cases.

designer/client/src/components/toolbars/scenarioActions · high confidence

The Flink executor now supports configurable job parameters via a new reference.conf, allowing users to set checkpoint intervals, enable RocksDB state backend, configure async execution workers, and define restart strategies. Additionally, a new FlinkScenarioNameValidator enforces stricter naming rules for scenarios, rejecting names with leading/trailing whitespace and allowing only alphanumeric characters, underscores, hyphens, and internal spaces.

engine/flink/executor · high confidence

The graph reducer logic has been restructured into a modular set of files, introducing dedicated reducers for live data state, testing results, and test cases, alongside utilities for handling node layout, ID mapping, and edge validation. This change enhances the designer's ability to manage complex graph operations, such as copying nodes with unique identifiers and maintaining consistent test case assertions when nodes are modified or deleted.

designer/client/src/reducers/graph · high confidence

The Kafka utilities now cache topic lists and auto-create settings via a configurable \CachingKafkaAdminClient\, reducing redundant admin API calls. Additionally, the Kafka error topic serialization for exceptions now enforces a maximum message size by truncating large \inputEvent\ variables, ensuring error messages fit within Kafka's limits.

utils/kafka-utils · high confidence

The SVG export process now produces cleaner, more compatible files by automatically hiding non-exportable UI elements (such as link tools and markers), removing hidden nodes, and fixing incompatible SVG attributes like 'orient'. Additionally, the exported SVGs now include embedded styles and images, ensuring the visual appearance is preserved correctly when the file is opened externally.

designer/client/src/components/graph/svg-export · high confidence

Applied patches to three client dependencies to enhance usability and stability. For @glideapps/glide-data-grid, group header renaming now correctly saves changes on blur or click-outside (previously discarded), and column dragging is enabled for single-column groups. For react-draggable, the findDOMNode deprecation warning in React 18 is resolved by correctly handling the nodeRef prop. For ts-spel, the library was replaced with a custom fork to support newer regex features.

designer/client/patches · high confidence

The reconciliation process now handles job recovery sequentially rather than all at once, preventing resource contention and ensuring that only the current leader initiates recovery tasks. Additionally, a new scheduler synchronizes local statuses for finished deployments, ensuring that the system correctly marks deployments as execution-finished even if engine-side job history is retained or lost. These changes improve reliability and stability in High Availability deployments.

designer/server/src/main/scala/pl/touk/nussknacker/ui/process/deployment/reconciliation · high confidence

The system now provides more robust handling of deployment status queries by introducing a wrapper that adds timeout support and specific error categorization (such as timeouts, configuration errors, and failures) to prevent silent issues. Additionally, a new provider class merges engine-side status data with local store information to ensure accurate status reporting during edge cases like pending deployments or job retention, while also adding warning logs for deployments in problem states to improve operational visibility.

designer/server/src/main/scala/pl/touk/nussknacker/ui/process/deployment/deploymentstatus · high confidence

The Flink engine now uses a new, non-macro-based serialization infrastructure for Scala case classes and \Option\ types, replacing the previous macro-generated serializers. This change introduces dedicated \TypeSerializer\ and \TypeComparator\ implementations (e.g., \ScalaCaseClassSerializer\, \OptionSerializer\) along with their corresponding \TypeSerializerSnapshot\ classes to ensure robust state backend compatibility and checkpointing. Users benefit from more reliable serialization of case classes that include fields defined in the class body or secondary constructors, as well as proper handling of \Option\ types (including \None\ cases) during data processing.

engine/flink/scala-utils · high confidence

The scenario-api now defines a new canonical representation of process graphs via the \CanonicalProcess\ and \ScenarioGraph\ types, replacing the legacy \EspProcess\ structure. This change introduces a dedicated \ScenarioBuilder\ DSL for constructing scenarios programmatically and a \CanonicalProcessConverter\ to handle serialization and migration between the new canonical format and the legacy graph format. The update also adds support for sticky notes and test cases within the graph structure, and refactors the canonization logic to support scenarios that end without a sink.

scenario-api · high confidence

The live-data-collector now enforces a configurable retention period for collected live data. The \CollectedLiveData\ model and its underlying storage (\LiveDataCollectingListenerStorage\) filter out samples older than the configured \retentionTime\, ensuring that only recent data is retained in memory and uploaded to the database. This change supports the NU-2359 requirement to manage data volume and relevance by automatically discarding stale live data samples.

live-data-collector · high confidence

A new \FetchScenarioActivityService\ has been added to centralize the logic for retrieving scenario activity records. This service resolves a process name to its ID and queries the activity repository, returning a list of activities or a specific error if the scenario is not found. This change refactors how activity data is fetched, separating the resolution and retrieval logic from other parts of the system.

designer/server/src/main/scala/pl/touk/nussknacker/ui/process/scenarioactivity · high confidence

The fragment input definition UI now uses a dedicated Item component to render individual input parameters, featuring a type selector that displays simplified class names (e.g., 'String') while internally resolving and storing full Java class names (e.g., 'java.lang.String') for backend compatibility. This change adds support for generic types and validates parameter names and types, ensuring that fragment inputs are correctly typed and validated within the node modal.

designer/client/src/components/graph/node-modal/fragment-input-definition/item · high confidence

The designer client now uses explicit TypeScript interfaces to define its internal data structures, replacing implicit or loosely typed definitions. New type files establish the shape of the scenario graph (nodes, edges, sticky notes, and test cases), component definitions (parameters, return types, and UI configuration), and validation results (including specific error types for nodes, test cases, and global process properties). This change provides stricter type safety for the visual editor's state and configuration without altering user-facing behavior.

designer/client/src/types · high confidence

The designer server now includes a new database package (\pl.touk.nussknacker.ui.db\) that establishes the foundational infrastructure for database interactions. This introduces \DatabaseInitializer\ to manage Flyway migrations for PostgreSQL and HSQLDB, \DbRefInstance\ to create and configure database references based on configuration, and \DBIOActionExtensions\ to provide convenient execution methods for database actions. Additionally, \NuTables\ aggregates various entity factories (such as Process, ScenarioActivity, and Deployment), and \SqlStates\ defines standard SQL error codes, collectively replacing or supplementing previous database access patterns with a more structured, Slick-based approach.

designer/server/src/main/scala/pl/touk/nussknacker/ui/db · high confidence

The system now supports configurable validation modes for variable names, introducing 'strict' and 'lax' options via the new ValidationMode enum. Strict mode requires all fields including optional ones without redundancy, while lax mode only requires required fields. This change also includes a new Validations object that provides methods to validate variable names against Java identifier rules, enhancing the precision of validation errors reported during node configuration.

components-api/src/main/scala/pl/touk/nussknacker/engine/api/validation · high confidence

The JSON decoding engine in the components API has been refactored to support union types, allowing fields to accept multiple possible data types, and to handle a broader range of logical types such as dates, times, locales, and currencies. This change introduces new decoders that can infer and decode complex structures based on typing results, improving the flexibility of JSON processing for scenarios involving schemaless topics or dynamic data formats.

components-api/src/main/scala/pl/touk/nussknacker/engine/api/json/decoders · high confidence

Added local Cypress configuration files to streamline local development. The new \designer-config-customizations.conf\ enables multiple test cases by default and configures deployment comment validation to accept any input, removing the previous requirement for specific comment formats during local runs. Additionally, a \tsconfig.json\ file was introduced to define TypeScript compilation settings for Cypress tests, including support for visual regression and drag-and-drop plugins.

designer/client/cypress · high confidence

The core metrics interfaces and their no-operation implementations have been relocated to the components-api module. This change introduces the MetricsProviderForScenario trait along with supporting types like MetricIdentifier, Gauge, Counter, Histogram, and RateMeter, providing a unified abstraction for scenario-level metrics that can be implemented by different engine backends.

components-api/src/main/scala/pl/touk/nussknacker/engine/util/metrics · high confidence

The common component library has been updated to use Material-UI (MUI) for styling and layout, replacing previous styling approaches. This includes new implementations for a date/time picker (DTPicker), a date display component (Date), a dropdown button with integrated select logic (DropdownButton), an expandable accordion section (Expandable), and a label component that displays error counts with tooltips (LabelWithErrorIndicator). These changes standardize the visual appearance and behavior of shared UI elements across the designer client.

designer/client/src/components/common · high confidence

The designer's styling layer has been converted from Stylus to TypeScript, introducing new files for typed style definitions and layout constants. SelectStyled.ts provides a theme-aware, MUI-based styling system for custom select components, handling states like focus, error, and disabled with dynamic color blending. variables.ts centralizes layout dimensions (sidebar, panel, modal, and dialog widths) previously managed by Stylus, ensuring consistent sizing across the designer interface.

designer/client/src/stylesheets · high confidence

The Ad-hoc Testing modal now presents a configurable form for entering test parameters, replacing the previous simpler interface. Users can input values via type-specific editors (e.g., SpEL expressions), with real-time client-side validation and backend validation upon submission. The dialog supports dynamic content via Markdown directives (\::form-fields\, \::form-field\) to customize the layout, and includes a 'Test' button that is disabled until parameters are valid, ensuring data integrity before the test process is triggered.

designer/client/src/components/modals/AdhocTesting · high confidence

The client's HTTP layer now includes new utility functions in \parametersUtils.ts\ to automatically fix branch parameter templates and correct aggregate node parameters (specifically handling \aggregateBy\ and aggregator expressions) before they are sent to the backend. Additionally, \resultsWithCountsDto.ts\ introduces comprehensive TypeScript interfaces for test results, adding support for node transition results, expression evaluation results, external service invocation results, and detailed assertion outcomes, while deprecating older result structures to align with the new multi-test-case and live-data display capabilities.

designer/client/src/http · high confidence

The \engine/lite/components-api\ module now provides the foundational Scala types and traits for the Nussknacker Lite engine, introducing a unified API for defining sources, sinks, and custom components. This change establishes core abstractions such as \LiteSource\, \LiteSink\, and \LiteCustomComponent\ which utilize \CustomComponentContext\ (carrying \NodeId\ and \NodeName\) and \DataBatch\ for processing. It also includes runtime context preparation via \LiteEngineRuntimeContextPreparer\ and utility traits like \BaseLiteSource\ and \SingleElementComponent\ to standardize how components handle context variables, trace IDs, and error collection using Cats \Writer\ monads.

engine/lite/components-api · high confidence

The designer's REST API now exposes a new set of data structures in the \definition\ package to support the frontend with detailed component and parameter metadata. This includes \UIDefinitions\ which aggregates component groups, individual component definitions (\UIComponentDefinition\), scenario properties, and node edge information. \UIParameter\ has been expanded to include fields such as \hintText\, \label\, \requiredParam\, \category\, \changesCanReloadParameters\, and \nonImportantForExecution\, allowing the UI to render more contextual help and validation rules. Additionally, \UiScenarioPropertyConfig\ now supports \hintText\ and \label\ fields, and \UIComponentDefinition\ includes a \docsUrl\ and \label\ for better discoverability and documentation access within the designer interface.

designer/restmodel/src/main/scala/pl/touk/nussknacker/restmodel/definition · high confidence

The REST model layer now defines structured DTOs for key scenario management actions, replacing or supplementing previous plain-text or ad-hoc approaches. Users can now send a CancelRequest with an optional comment to cancel a scenario, and a DeployRequest that includes an optional comment, node-specific deployment data, and the scenario graph source to support saving scenarios during deploy/redeploy operations. A new RunOffScheduleRequest (with an optional comment) supports the renamed 'Run off schedule' action, returning a RunOffScheduleResponse indicating success or failure. Additionally, a DeployResponse provides the version ID of the deployed scenario, and BaseEndpointDefinitions establishes the Tapir-based security framework (handling authentication and authorization errors) for these endpoints.

designer/restmodel/src/main/scala/pl/touk/nussknacker/restmodel · high confidence

The Scenario Activity API has been updated with new endpoints and data structures to support a richer activity history. The \Dtos.scala\ file introduces a new \ScenarioActivitiesMetadata\ model that defines available activity types (such as created, deployed, modified, and autosaved) and their supported actions (like add, edit, or delete comments, compare, and download attachments). Corresponding Tapir endpoints in \Endpoints.scala\ now expose these metadata details alongside the standard activity list, comment management, and attachment handling, allowing clients to dynamically render activity-specific actions and icons based on the scenario type.

designer/server/src/main/scala/pl/touk/nussknacker/ui/api/description/scenarioActivity · high confidence

The Designer API layer has been refactored to use the Tapir framework, introducing new HTTP service implementations for core functionalities including action parameters, application health and configuration, component definitions, deployment management, dictionary queries, scenario migration, and node validation. These services replace the previous Akka HTTP route definitions with a unified, type-safe endpoint structure, while preserving existing authorization logic and business service integrations.

designer/server/src/main/scala/pl/touk/nussknacker/ui/api · high confidence

The graph designer now includes a new set of TypeScript utilities in the GraphPartialsInTS module to handle cell updates, layout calculations, and paper configuration. These changes introduce specific logic for managing sticky notes (including advanced styling and tool attachment), filtering out disconnected edges, and applying directed graph layouts using dagre. Users will see improved handling of sticky note elements within the graph structure and more robust cell synchronization when the underlying scenario graph changes.

designer/client/src/components/graph/GraphPartialsInTS · medium confidence

A new \ButtonBaseStyle.tsx\ file has been introduced to define the foundational styles for buttons. This style object applies the theme's button typography, enforces capitalized text, removes border radius, sets the background color to the theme's paper color, and adds a transition effect. It also explicitly handles disabled states by reducing opacity and changing the cursor to 'not-allowed'.

designer/client/src/components/button · high confidence

The settings interface has been replaced with a new implementation that features a collapsible list of user settings, allowing users to expand and collapse nested setting groups. A search field is now available to filter settings by keyword, with matching text highlighted in the list. Users can toggle individual settings between ON, OFF, and DEFAULT states, and delete custom overrides. The view also supports keyboard navigation, allowing users to focus the search field by typing and toggle a single filtered setting by pressing Enter.

designer/client/src/containers/settings · high confidence

The comment section now uses newly created React components (CommentContent, CommentInput, StyledComment) that replace previous stylus-based styling with MUI's styled API. CommentContent renders comment text with XSS sanitization, supports search-word highlighting, and handles link substitution via MUI Typography and Link. CommentInput provides a styled textarea with a default placeholder. These changes affect how comments are displayed and entered in the designer client.

designer/client/src/components/comment · high confidence

The designer server now ships with a new \defaultDesignerConfig.conf\ file that establishes sensible defaults for database connections (HSQLDB), HTTP settings (port 8080), and Pekko actor system parameters, including relaxed URI parsing and a 1-second connection backoff. This configuration also defines the default toolbar layout for process editing, specifying which panels and buttons are visible based on user roles (e.g., hiding deploy actions for 'Reader' and 'Demo' users) and process states (e.g., hiding actions for archived processes or fragments). Additionally, a new \encryption.key\ file is included, providing a default key for sensitive data encryption.

designer/server/src/main/resources · high confidence

The designer now tracks deployment status in a dedicated database table, allowing users to see detailed deployment states (such as running, finished, or problem) and ensuring that only one deployment runs per scenario at a time to prevent conflicts.

designer/server/src/main/scala/pl/touk/nussknacker/ui/process/newdeployment · high confidence

The error section of the tips panel now uses a new set of React components (ErrorHeader, ErrorTips, Errors, HeaderIcon, NodeErrorLink, NodeErrorsLinkSection, ScenarioPropertiesSection, TestCaseErrorTips, TestCaseErrors) to display validation errors. These components render error messages, provide links to specific nodes or scenario properties, and include an 'Ask Assistant' button for AI assistance. The styling has been updated to use MUI components and custom styled wrappers.

designer/client/src/components/tips/error · high confidence

The system now introduces specific exception classes to handle distinct error scenarios during scenario management. DeployingInvalidScenarioError is added to explicitly handle cases where a scenario fails validation during deployment, carrying the specific validation errors. ProcessValidationError is introduced to wrap general process validation failures as bad request errors. Additionally, ProcessIllegalAction is defined to provide detailed error messages when an action is attempted on a scenario in an incompatible state (such as archived or fragment scenarios), including the specific action name, scenario name, current state, and list of allowed actions.

designer/server/src/main/scala/pl/touk/nussknacker/ui/process/exception · high confidence

The expression editor area now uses a new set of wrapper components (AceWrapper, AceWithSettings, CustomCompleterAceEditor) that integrate user settings (line numbers, wrap) and custom tab navigation. It introduces context-aware snippet insertion for JSON and SpEL template editors (e.g., smart Enter behavior in objects, \#{ } template placeholders) and replaces regex-based completions with a backend-driven suggestion system (BackendExpressionSuggester + CustomAceEditorCompleter) that provides descriptions, parameters, and bracket access hints. A new BoolEditor allows switching to a toggle when the expression is true/false, and the editor registry (Editor.ts) centralizes editor selection by type.

designer/client/src/components/graph/node-modal/editors/expression · high confidence

The migration subsystem now includes specific model migrations, such as renaming the 'keyBy' parameter to 'groupBy' in aggregate nodes and 'value' to 'Output expression' in union nodes. It also introduces a new test framework that validates scenarios after migration to detect new validation errors, and refactors the remote environment communication to support API versioning and improved error handling during scenario transfers.

designer/server/src/main/scala/pl/touk/nussknacker/ui/process/migrate · high confidence

The save scenario modal now includes a comment input field, allowing users to attach notes when saving. The underlying save logic has been updated to persist the scenario draft as a new version, clear the draft state, and broadcast a version bump to other tabs. Additionally, if the scenario name was changed during the save operation, the application automatically navigates to the new URL path to reflect the rename.

designer/client/src/components/modals/saveScenario · high confidence

The Table editor in the expression node modal now uses a dedicated React state management layer (hooks and reducers) to handle table data. This change introduces support for specific user actions including inserting, editing, and deleting rows and columns, resizing columns, renaming columns, changing column data types, and moving columns. It also ensures that the table state is synchronized with external expression changes (such as undo/redo) and maintains a minimum table size.

designer/client/src/components/graph/node-modal/editors/expression/Table/state · high confidence

The type system now includes new \ClassHierarchyCommonSupertypeFinder\ and \CommonSupertypeFinder\ components to more accurately determine the nearest common supertype for class hierarchies and complex typing results (such as records and unions). Additionally, a \NumberTypesPromotionStrategy\ has been introduced to handle numeric type widening for various operations (math, large numbers, min/max, power), ensuring that expressions involving mixed numeric types are inferred with the appropriate wider type.

components-api/src/main/scala/pl/touk/nussknacker/engine/api/typed/supertype · high confidence

The system now introduces specific data structures to represent validation errors for test cases defined at the scenario level. This change adds a new package containing case classes for node-level test case errors, enricher mock validation errors, and assertion validation errors, along with the logic to combine these errors. This enables more granular reporting of issues found during the validation of test scenarios.

designer/restmodel/src/main/scala/pl/touk/nussknacker/restmodel/validation/testcase · high confidence

The designer client now uses a new window management system built on the @touk/window-manager library, replacing the previous implementation. This change introduces lazy-loaded dialogs for all modal types (such as node details, save, deploy, and AI assistant) to improve performance, and standardizes UI components like buttons and headers using Material UI (MUI). It also adds specific behavioral improvements, including removing focus from input fields when the Escape key is pressed in dialogs and preventing background dragging on touch devices.

designer/client/src/windowManager · high confidence

The notification system has been migrated from in-memory storage to a database-backed implementation, ensuring that deployment action notifications (such as deploy, redeploy, and cancel failures or completions) and scenario activity updates are persisted and reliably delivered to users. This change introduces a new \NotificationService\ that fetches notifications based on the logged-in user and, when viewing a specific scenario, includes activity-related updates for that scenario, replacing the previous in-memory approach with a durable store that supports scoped retrieval.

designer/server/src/main/scala/pl/touk/nussknacker/ui/notifications · high confidence

This change introduces two new utility objects in the deployment manager API to improve performance and code clarity. The new \AdditionalComponentConfigsForRuntimeExtractor\ filters component configuration data sent to the runtime (Flink) to include only parameters with dictionary editors, significantly reducing the payload size. Additionally, \WithDataFreshnessStatusUtils\ provides implicit extension methods for \WithDataFreshnessStatus\ collections, simplifying the retrieval and mapping of scenario status data.

designer/deployment-manager-api/src/main/scala/pl/touk/nussknacker/engine/util · high confidence

The process toolbar buttons (Archive, Unarchive, Compare, Export, Import, Migrate, PDF, and Save) have been restructured into individual, dedicated React components. This change introduces specific behaviors for each action, such as the Save button now supporting quick-save presets and validating against outdated versions before saving, the Archive/Unarchive buttons handling state transitions and navigation, and the Export/Import/Migrate buttons integrating with the HTTP service for data transfer. The toolbar now uses these specialized components to manage user interactions, permissions, and UI states more granularly.

designer/client/src/components/toolbars/process · high confidence

The MenuBar component has been rewritten to introduce a new top navigation structure. It now includes a Breadcrumbs component that displays the current environment and allows switching between active scenarios via a dropdown menu. Tab navigation has been enhanced with the TabElement component, which supports both internal routing and external URL links, and automatically appends the current page URL as a query parameter for external links. The menu bar also features a configurable InstanceLogo that handles loading states and errors, and a HideIfEmbedded wrapper that suppresses the entire menu when the application is loaded as an iframe (detected via a query parameter). The menu items are rendered in a truncated list with an expandable popup for overflow items, and styling has been migrated to MUI.

designer/client/src/components/MenuBar · high confidence

The Tips panel in the designer has been rebuilt using MUI components and Emotion for styling, replacing the previous implementation. This change introduces a new visual layout for displaying validation errors, warnings, and success states, including a highlighted state for active tips. Additionally, the panel now integrates an 'Ask Assistant' button that allows users to request explanations for scenario validation problems directly from the AI assistant.

designer/client/src/components/tips · high confidence

The Activity Panel row items have been refactored to support richer interactions and clearer status indicators. Each row now displays a local draft notice with a 'Discard draft' button when a local draft exists for the version, allowing users to revert to the clean server state. The panel also supports adding, editing, and deleting comments on activities, with actions appearing on hover and respecting user write permissions. Additionally, users can compare scenario versions directly from the activity list, download or delete file attachments, and benefit from improved date formatting and visual highlighting for search matches and active deployments.

designer/client/src/components/toolbars/activities/ActivityPanelRowItem · high confidence

The designer client's startup sequence has been restructured to improve modularity and deployment flexibility. A new \bootstrap.tsx\ file now serves as the central entry point, establishing the React 18 root, configuring the \react-router-dom\ browser router with a dynamic base path, and wrapping the application in a provider hierarchy (including \NuThemeProvider\, \ErrorBoundary\, \StoreProvider\, and \AiAssistantProvider\). Initialization is managed via \init.js\, which loads configuration and styles before triggering the bootstrap. Configuration is now centralized in \config.ts\, supporting dynamic public paths for deployment under non-root URLs. Additionally, new utility modules have been introduced: \WrapAllMethods.ts\ provides a decorator for automatically wrapping class methods, \api.ts\ defines the Axios instance, \devHelpers.ts\ adds logging and error handling utilities, and \i18n.ts\ configures internationalization with language detection and backend loading.

designer/client/src · high confidence

The counts modal has been rebuilt to offer a more flexible time-range selection. Users can now choose from predefined quick ranges (e.g., Last hour, Today) or select specific start and end times using date pickers. A new feature allows enabling auto-refresh for live data, with configurable intervals (10, 30, 60, or 300 seconds). Additionally, the dialog now integrates with the activities endpoint to suggest time ranges based on previous process activities (such as deployments or runs), with specific filtering for batch processes to exclude deployment events that don't immediately trigger execution.

designer/client/src/components/modals/CalculateCounts · high confidence

The component toolbar in the scenario designer has been completely refactored to improve usability and extensibility. The new CreatorPanel introduces a text search filter that highlights matching components within grouped toolboxes, replacing the previous flat list. Component groups are now collapsible, with their open/closed state persisted in user settings, and sticky notes are organized into a dedicated 'Misc' group with configurable limits. The panel now supports remote component groups via federated modules, allowing dynamic addition of component categories. Additionally, the toolbox integrates with the Command Bar for keyboard navigation and exposes an AI tool interface, enabling users to create nodes programmatically using natural language commands through the 'get\_components' and 'add\_new\_node' tools.

designer/client/src/components/toolbars/creator · high confidence

The edit toolbar buttons have been refactored into dedicated React components (CopyButton, DeleteButton, LayoutButton, PasteButton, RedoButton, UndoButton) that integrate with the new selection context and Redux store. Undo and Redo buttons now display a counter badge indicating the number of available actions. The Layout button supports alignment and distribution commands with keyboard shortcuts. Paste functionality includes a workaround for touch devices to ensure paste options are available.

designer/client/src/components/toolbars/edit · high confidence

The designer's graph experience has been overhauled with new behaviors for node placement and selection. A new 'AddComponentsButtons' container provides context-aware buttons to add nodes, while 'AdjustNodeOverlapBehavior' automatically repositions nodes to prevent overlaps upon creation. The 'NodeCreationHandler' now supports adding nodes via right-click on the canvas and by clicking on unconnected link endpoints. Keyboard shortcuts for actions like select-all, undo, redo, and delete are now centrally managed in 'BindKeyboardShortcuts' with integrated event tracking. The application shell has been restructured into a new 'NussknackerApp' container that integrates the command bar, AI assistant tools, and a robust notification system that polls for backend updates and handles connection errors.

designer/client/src/containers · high confidence

The visual representation of nodes in the process graph has been updated to include test result counts and assertion statuses, with error states highlighted in red. Node labels and descriptions are now truncated to a maximum of two lines to maintain a consistent layout. Additionally, the connections between nodes now use a Manhattan-style router for cleaner orthogonal paths and display dynamic labels, improving the clarity of the workflow diagram.

designer/client/src/components/graph/EspNode · high confidence

The node details modal has been refactored to use a tabbed layout, introducing a dedicated 'Testing' tab alongside the existing 'General' tab, allowing users to view test results and manage test cases directly within the node view. The modal now features a new edit state system that provides immediate visual feedback (pending/applied toasts) for property changes and supports manual apply workflows. Additionally, fragment nodes now display an inline graph preview within the modal, and the window header has been enhanced with custom cursor styling for improved drag-and-drop interaction.

designer/client/src/components/graph/node-modal/node · high confidence

The node modal's input and output panels have been rebuilt to provide a richer, more interactive inspection of variable contexts. Users can now view live data in collapsible accordions that display timestamps, error states, and related node connections. The interface offers a toggle between a structured tree view and a raw JSON view, supports drag-and-drop of values and keys for expression building, and includes side panels that can be resized and filtered by connected nodes. A new 'LIVE' indicator and smooth animations reflect real-time data updates, while an improved empty-state message guides users to run tests or deploy to see data.

designer/client/src/components/graph/node-modal/io · high confidence

The node details modal header has been refactored to display a more structured title area. It now includes a subtype badge (styled with background color logic based on theme luminance) and, when available, a clickable 'Docs' link that opens the component's documentation in a new tab and is tracked via event tracking. The header also supports custom start/end icons and extracts the label and documentation URL from the node's component definition, ensuring the modal title reflects the specific node type and language.

designer/client/src/components/graph/node-modal/nodeDetails · high confidence

The scenario details section of the toolbar has been restructured into a new set of components (ScenarioDetails, ScenarioStatusPanel, CategoryDetails, ScenarioLabels, ScenarioNameItem) that display the scenario name, processing mode icon, category, and version. A key behavioral change is the introduction of a dedicated label management interface (ScenarioLabels) which supports adding unique labels with real-time validation and delayed submission on Enter until validation finishes. The status panel also includes a 'More details' button that opens a dedicated window for extended scenario information.

designer/client/src/components/toolbars/scenarioDetails · high confidence

The side panels in the designer have been rebuilt using a new component architecture that supports collapsible states and automatic graph viewport adjustment. The new \CollapsiblePanel\ and \CollapsibleScrollPanel\ components handle panel expansion, hiding when empty, and scroll visibility, while the \SidePanelsContext\ manages state for left, right, and dynamic panels. A new \useGraphViewportAdjustment\ hook ensures the graph canvas automatically shifts to accommodate panel width changes, improving usability when toggling panels. The styling has been migrated to MUI's \styled\ API, replacing previous stylus-based styles, and includes custom scrollbars and error boundaries for robustness.

designer/client/src/components/sidePanels · high confidence

Sticky notes in the graph editor now feature a refreshed visual design with two distinct styles: a 'basic' style (default yellow) and an 'advanced' style (default dark brown), selectable via configuration. The new implementation introduces updated default dimensions (300x250 for basic, 180x130 for advanced), refined drop shadows, and improved markdown rendering with better link handling and error display. The resize tool has been adjusted to provide more precise control, and the overall appearance is now more consistent with the application's theme.

designer/client/src/components/graph/EspNode/stickyNote · high confidence

The client store has been migrated to Redux Toolkit, introducing a new configuration layer that includes a listener middleware for autosaving scenario drafts and a dedicated middleware for debounced backend validation of graph changes. This change adds draft persistence across browser tabs via redux-state-sync, ensures unsaved draft changes are tracked to prevent data loss on navigation, and provides typed React hooks (useAppDispatch, useAppSelector) for improved type safety in components.

designer/client/src/store · high confidence

The toolbar button components have been rewritten to use MUI's styled API, replacing the previous styling approach. This change introduces a unified button system that supports multiple visual variants (xs, small, label, horizontal, menu) and new interaction modes: buttons can now display loading progress, accept file drops via drag-and-drop, and present preset selection menus. Additionally, all buttons now include hover tooltips for better discoverability, and the layout has been adjusted to fix previous blinking issues and improve icon sizing across different toolbar configurations.

designer/client/src/components/toolbarComponents/toolbarButtons · high confidence

The toolbar system has been rebuilt to support flexible positioning and user-driven reordering. Toolbars can now be dragged and dropped to rearrange their order within their containers, with visual feedback provided during the drag operation. The layout has been updated to support toolbars floating above the node window, as well as positioning in the left, right, top, and bottom areas of the designer interface. This change introduces a new drag-and-drop infrastructure using @hello-pangea/dnd, including custom sensors for mouse, touch, and keyboard interactions, and updates the visual styling of toolbar containers and items to reflect the new layout capabilities.

designer/client/src/components/toolbarComponents · high confidence

The Flink MiniCluster implementation has been restructured into a dedicated module, introducing a new \FlinkMiniClusterConfig\ to allow configuration of the Job Manager REST API timeout and enabling the use of a \StreamExecutionEnvironment\ for node compilation. This refactor decouples scenario statuses from deployment statuses and adds configurable timeouts for scenario testing and state verification. The module now provides dedicated runners and verifiers for scenario testing and state verification, supporting configurable parallelism and retry policies, while removing the previous fallback to single-use MiniClusters in these mechanisms.

engine/flink/minicluster · high confidence

The JSON encoding system in the components API has been refactored to introduce distinct encoding behaviors: a strict encoder that fails fast on unsupported types to aid debugging, and a loose encoder that falls back to string representation for unknown values. This change includes new files for handling results variables, type encoding for schemaless topics, and a fallback mechanism for standard types (dates, collections, enums, etc.), ensuring more robust and configurable JSON serialization for scenario variables and typing results.

components-api/src/main/scala/pl/touk/nussknacker/engine/api/json/encoders · high confidence

The Kafka test utilities have been refactored to replace the legacy Zookeeper-based embedded server with a KRaft (Kafka Raft) mode implementation. This change introduces new components such as \EmbeddedKafkaKraftServer\ to manage the embedded cluster lifecycle and \KafkaClient\ to handle topic creation, message sending, and consumer management. The test base trait \KafkaSpec\ now initializes the KRaft server and configures the bootstrap servers automatically, ensuring tests run against the modern, Zookeeper-free Kafka architecture.

utils/kafka-test-utils · high confidence

The component API in the definition package has been restructured to improve type safety and reduce boilerplate for component developers. A new \ParameterDeclaration\ builder and \ParameterExtractor\ system now handles the creation and extraction of parameters (mandatory, optional, lazy, and branch variants) with explicit type tags, ensuring definitions stay synchronized with implementation. The \Parameter\ case class has been expanded with new fields such as \variablesToHide\, \changesCanReloadParameters\, and \nonImportantForExecution\ to support advanced UI and execution behaviors. Additionally, the validation system now distinguishes between \CompileTimeValidator\ and \RuntimeValidator\, introducing specific validators for duration types and a \ValidationExpressionParameterValidatorToCompile\ that allows configuration via files or UI providers, while \NodeDependency\ and \EngineScenarioCompilationDependencies\ provide a cleaner mechanism for managing node-level dependencies during compilation.

components-api/src/main/scala/pl/touk/nussknacker/engine/api/definition · high confidence

The component and scenario property definition logic has been restructured into new service classes to improve separation of concerns and configuration handling. A new AlignedComponentsDefinitionProvider now centralizes the assembly of built-in components, fragments, and model definitions, while the updated DefinitionsService orchestrates the preparation of UI definitions by combining these components with static definitions and scenario property configurations. Additionally, a ScenarioPropertiesConfigFinalizer has been introduced to merge additional UI configuration providers with existing scenario property settings, and an EdgeTypesPreparer manages the mapping of component outputs to frontend edge types, ensuring consistent visualization of fragment and custom component connections.

designer/server/src/main/scala/pl/touk/nussknacker/ui/definition · high confidence

The component definition service has been refactored to improve how components are grouped, validated, and tracked. Component groups are now prepared with explicit sorting rules (Sources/Fragments, Base, Services/Sinks, Others) and merged when group mappings overlap. Node templates are generated with unique IDs and names, supporting various component types like filters, splits, services, and fragments. A new validator ensures consistency across component definitions by checking for duplicate names, icons, types, and group names. Usage tracking has been enhanced to correctly handle fragment usages, resolving fragment references to their actual node usages within scenarios. The service also supports fetching component lists with or without usage counts and usages per component.

designer/server/src/main/scala/pl/touk/nussknacker/ui/definition/component · high confidence

The deployment logic in the designer server has been restructured to use a command-based pattern, introducing new services like ActionService and ActionInfoService to manage scenario actions (deploy, cancel, run off schedule) and retrieve action parameters. This change decouples action execution from state management, ensuring transactional consistency and providing a unified way to handle deployment commands and their associated metadata.

designer/server/src/main/scala/pl/touk/nussknacker/ui/process/deployment · high confidence

The settings panel for fragment input parameters has been restructured into a modular, variant-based architecture. A new \Settings\ component now routes to specific sub-components (\DefaultVariant\, \PermittedTypeVariant\) based on the parameter type, while a \SettingsProvider\ manages temporary state for user-defined lists and compile-time validation. This change introduces dedicated UI fields for different input modes (Fixed list, Any value with suggestions, Any value), including new components for managing fixed values via dictionaries or user-defined lists, and a refined validation expression editor, resulting in a more consistent and maintainable configuration experience.

designer/client/src/components/graph/node-modal/fragment-input-definition/settings · high confidence

The NodeDetailsContent module has been restructured to improve maintainability and styling consistency. New React components have been introduced: DebugNodeInspector for visualizing node data using react-inspector, NodeDetailsFallback for handling unknown node types with validation error display, and NodeTableStyled which centralizes MUI-based styling for node inputs, checkboxes, and Ace editors. Additionally, the Redux layer has been updated with new selectors in selectors.tsx and getNodeDetails.tsx to manage node details, validation errors, and dynamic parameter definitions using reselect, alongside helper functions in helpers.ts to extract parameters based on node type.

designer/client/src/components/graph/node-modal/NodeDetailsContent · high confidence

The field editors within the node configuration modal have been rewritten to use a new set of MUI-based form components (Checkbox, Input, LabeledInput, LabeledTextarea, MarkdownFormControl, and FieldSwitch). This change replaces the previous implementation with a more structured, type-safe approach for rendering node inputs, including a new FieldSwitch component that manages switching between different expression editors (such as SpEL, JSON, and SQL) and integrates with user settings for debug modes. Users will see a consistent UI styling across all node field inputs, improved validation display, and better support for switching between expression types directly within the node configuration.

designer/client/src/components/graph/node-modal/editors/field · high confidence

The node-modal components have been rewritten to replace the previous form implementations with a new set of MUI-based field editors. This change introduces dedicated components for managing node properties, such as \BaseBuilderFieldWrapper\ for expression builders, \BranchParameters\ for handling branch-specific logic, and \EdgesDndComponent\ for drag-and-drop edge management. The refactoring standardizes the UI by using \NodeField\ and \FieldLabel\ for consistent input rendering, validation, and error display, while also integrating the \DataMapperComponent\ for complex field mapping. Users will see a more consistent and robust interface when editing node details, with improved support for expression builders and dynamic field validation.

designer/client/src/components/graph/node-modal · high confidence

The backend process service has been refactored to use a new \ProcessService\ trait and \ScenarioQuery\ model, improving how scenarios are fetched and filtered. A new \ScenarioToolbarService\ allows toolbar buttons and panels to be configured per category, with visibility and titles dynamically determined by user roles and scenario state. Additionally, new services for scenario activity audit logging, attachment management, and version difference comparison have been added to enhance the scenario lifecycle tracking and UI capabilities.

designer/server/src/main/scala/pl/touk/nussknacker/ui/process · high confidence

The Process component area has been updated to use a new state model where scenario status and deployment statuses are decoupled, introducing specific types like ProcessStateType and StatusRunning. This change brings a new ProcessBackButton for navigation, a ProcessStateIcon with a Popover for detailed status tooltips, and a dedicated ProcessStateUtils class to handle logic for visible/allowed actions (Deploy, Redeploy, Cancel, Archive, RunOffSchedule). The UI styling has been migrated to MUI, replacing previous dependencies, and the component now supports new features like scenario labels and fragment handling.

designer/client/src/components/Process · high confidence

The processing type configuration loading and validation logic has been restructured into a new set of dedicated classes within the \processingtype\ package. This change introduces \ProcessingTypeData\ and \DesignerModelData\ to centralize model and deployment information, while \DeploymentData\ and \InvalidDeploymentManagerStub\ handle deployment manager initialization and error stubbing. A new \ScenarioParametersService\ and \ScenarioParametersDeterminer\ manage scenario parameters, processing modes, and engine setup names, including validation for ambiguous mappings and invalid engine configurations. Additionally, \ModelClassLoaderProvider\ enforces consistency during reloads, and \ProcessingTypeServices\ aggregates the necessary services for each processing type.

designer/server/src/main/scala/pl/touk/nussknacker/ui/process/processingtype · high confidence

The internal mechanism for loading processing-type configurations has been restructured into dedicated loader components (DeploymentManagersLoader, ModelDataLoader, ProcessingTypeDataStateFactory). A key behavioral improvement is the introduction of DeploymentManagerProviderCorrectClassloaderHandler, which ensures that the correct context classloader is active during deployment manager initialization. This prevents resource-loading failures (such as those involving Java resources or configuration parsing) that could occur when classloader contexts were mismatched, particularly in environments like Kubernetes.

designer/server/src/main/scala/pl/touk/nussknacker/ui/process/processingtype/loader · high confidence

The scenario action buttons in the designer toolbar (Deploy, Redeploy, Cancel Deploy, Run Off Schedule, and Properties) have been rewritten as new components. This introduces a 'quick action' mode for Deploy, Redeploy, and Cancel Deploy, allowing users to execute the primary action directly or access a configuration dialog via presets, controlled by user settings like \scenario.allowQuickDeploy\ and \scenario.allowQuickCancelDeploy\. The buttons now display loading states during processing and validate that the scenario version is the latest before deployment, warning users if they are working on an outdated version. Additionally, the 'Perform single execution' action is now labeled 'Run now', and the Properties button now indicates errors when property validation fails.

designer/client/src/components/toolbars/scenarioActions/buttons · high confidence

The scenario details response structure has been reorganized to improve clarity and reduce payload size. A new \ScenarioStatusDto\ model now explicitly separates the scenario's operational status (including running state details like version ID and start time) from the available UI actions and icons, replacing the previous flat structure. Additionally, a dedicated \ScenarioParameters\ model extracts processing mode, category, and engine setup name, while \ScenarioWithDetails\ now explicitly includes labels and uses a custom encoder to drop null values from the JSON response, resulting in a lighter payload for the scenarios tab. A separate \ScenarioWithDetailsForMigrations\ model ensures backward compatibility during environment migrations by handling optional labels and simplified validation results.

designer/restmodel/src/main/scala/pl/touk/nussknacker/restmodel/scenariodetails · high confidence

The deployment manager API now uses a decoupled model where scenario statuses and deployment statuses are handled separately. This change introduces \SimpleProcessStateDefinitionManager\ and \SimpleStateStatus\ to define state transitions, visible actions, and allowed actions based on the current scenario context. It consolidates various error states (Failing, Failed, Error, Warning, FailedToGet, MultipleJobsRunning) into a unified 'PROBLEM' status category, while preserving specific details for issues like multiple jobs running or scenarios that should not be running. Users will see more consistent status descriptions and tooltips, and the system now explicitly manages which actions are available for each status, improving clarity around deployment states and error handling.

designer/deployment-manager-api/src/main/scala/pl/touk/nussknacker/engine/api/deployment/simple · high confidence

The scenario status logic has been restructured to provide more accurate and detailed status reporting. A new InconsistentStateDetector resolves the final scenario status by combining engine-side deployment statuses with the last user action, specifically handling edge cases like version mismatches during deploy/redeploy and restoring 'Finished' status for engines with job retention. The ScenarioStatusProvider now orchestrates this resolution, optimizing performance by bulk-fetching deployment statuses for multiple scenarios and correctly identifying active scenarios based on the updated status definitions.

designer/server/src/main/scala/pl/touk/nussknacker/ui/process/deployment/scenariostatus · high confidence

The type-checking engine in the components API has been restructured to use a new \AssignabilityDeterminer\ that explicitly handles type assignment via configurable \Loose\ and \Strict\ conversion strategies. This change introduces \TypeConversionHandler\ to manage implicit conversions (such as numeric widening, date/time parsing, and array-to-list conversions) and \FromInstanceTypeDeterminer\ to infer types from runtime objects. Additionally, \TypedObjectTypingResult\ now uses \ListMap\ to preserve field order for Flink \Row\ serialization, and \TypingConfiguration\ allows controlling whether \Unknown\ types can be assigned to any target.

components-api/src/main/scala/pl/touk/nussknacker/engine/api/typed · high confidence

The validation logic in the designer server has been reorganized into specific, single-responsibility components: NodeValidator handles individual node validation, ParametersValidator manages parameter expression checks, ScenarioLabelsValidator enforces label rules, ScenarioPropertiesValidator validates scenario metadata, and FatalValidationError provides utilities for converting validation failures into HTTP errors. UIProcessValidator now orchestrates these components to validate the entire scenario graph, separating concerns from the previous monolithic approach.

designer/server/src/main/scala/pl/touk/nussknacker/ui/validation · high confidence

The live data preview API now returns more specific HTTP status codes to distinguish between different error conditions. When a scenario is not found, the API returns 404 Not Found. If live data preview is not supported by the scenario, it returns 422 Unprocessable Entity (instead of 501) to avoid triggering infrastructure alerts. When no live data is currently available for a running scenario, the API returns 204 No Content, providing a clearer signal to clients that the scenario is active but has no data yet, rather than an error.

designer/server/src/main/scala/pl/touk/nussknacker/ui/api/description/scenarioLiveData · high confidence

The request-response source and sink components in the lite engine have been refactored to derive their input and output types directly from JSON schemas defined in the OpenAPI metadata. This change replaces previous type-handling logic with a schema-based approach: the source now uses SwaggerBasedJsonSchemaTypeDefinitionExtractor to determine the context type from the input schema, and the sink validates output data against the output schema using JsonSchemaOutputValidator. A new 'collect' transformer has also been added to the request-response component set, which aggregates input data into a list and clears context variables. These changes ensure that request-response flows are strictly validated against their declared JSON schemas at design time and runtime.

engine/lite/components/request-response · high confidence

The SQL enrichers (DatabaseQueryEnricher and DatabaseLookupEnricher) now use connection pooling via HikariCP instead of creating new connections for each operation. This improves performance and resource management by reusing database connections. The configuration has been updated to use 'dataSourceProperties' instead of 'connectionsProperties' for pool settings.

components/sql/src/main · high confidence

The scenario testing API endpoints have been rewritten using the Tapir framework, introducing new data transfer objects for test capabilities, results, and requests. This change adds endpoints to query scenario and source test capabilities (including permission and source availability checks) and standardizes the serialization of test results, counts, and live data samples. The migration ensures consistent error handling and structured responses for test execution and validation operations.

designer/server/src/main/scala/pl/touk/nussknacker/ui/api/description/scenarioTesting · high confidence

The validation subsystem now returns structured error data that distinguishes between errors blocking rendering, errors blocking saving, and non-blocking warnings. This allows the user interface to provide more precise feedback, such as preventing the scenario from being saved while still allowing it to be viewed, or highlighting specific node parameters that are missing or duplicated. The new models also include typing information and node names to help the frontend adjust parameters and display accurate context for validation issues.

designer/restmodel/src/main/scala/pl/touk/nussknacker/restmodel/validation · high confidence

The toolbar wrapper component has been refactored to use Material UI (MUI) for its layout and typography, replacing previous styling approaches. The new implementation introduces a dedicated styled component file (ToolbarStyled.tsx) that defines specific styles for icon wrappers and collapse/close icons using MUI's styled API. The main wrapper component now leverages MUI's Panel, Typography, and ErrorBoundary components to manage toolbar state, drag handling, and error fallbacks, ensuring consistent visual styling and behavior across the designer's toolbar interface.

designer/client/src/components/toolbarComponents/toolbarWrapper · high confidence

The 'ui' module has been renamed to 'designer', introducing new structural components to support this change. This includes a placeholder file in the client translations directory, the addition of URI encoding/decoding codecs for the REST model, and the introduction of TypeScript type declarations for package metadata (name, version, build hash) in the submodules types.

designer/client/translations, designer/restmodel/src/main/scala/pl/touk/nussknacker/restmodel/codecs, designer/submodules/types · high confidence

The schemed-kafka-components-utils module has been refactored to provide a unified, schema-aware implementation for Kafka sources and sinks. This change introduces a new \KafkaUniversalComponentTransformer\ that dynamically configures parameters based on topic schema availability, supporting both schema-registered topics and schemaless JSON/plain content types. It includes a custom \NkSerializableParsedSchema\ for Flink serialization, an \AvroDefaultExpressionDeterminer\ to convert Avro defaults to SpEL expressions, and a comprehensive \AvroSchemaOutputValidator\ for strict and lax validation of record structures, unions, and logical types. Topic selection strategies now fetch fresh data from Kafka to support schemaless topics, and encoder customizations allow Avro records to be serialized to JSON and JSON Schema formats.

utils/schemed-kafka-components-utils · high confidence

The designer now uses a centralized ExpressionSuggester to provide code completion for SpEL, SpEL Template, and JSON Template expressions. This component delegates to the underlying SpEL suggester while correctly merging local variables with global context, ensuring that suggestions are accurate based on the current caret position and available variables within the expression editor.

designer/server/src/main/scala/pl/touk/nussknacker/ui/suggester · high confidence

The Docker Hub repository descriptions and README files for the main Nussknacker image, the Lite runtime app, and the Request-Response prototype app have been updated. The main Nussknacker image documentation now explicitly details usage for both Streaming (Lite engine) and Request-Response modes, including specific Docker run commands and environment variable configurations for Kafka and Schema Registry connectivity. New dedicated documentation has been added for the Lite runtime application, explaining its role in K8s deployments and how to manually invoke it with scenario and deployment data files. The Request-Response app documentation remains a prototype placeholder. A new shell script, publishReadme.sh, has been added to automate the synchronization of these READMEs and short descriptions to Docker Hub.

dockerhub · high confidence

The environment migration endpoint now uses a versioned data model (V1 through V3) to handle scenario migration requests, allowing the server to adapt incoming requests from older client versions to the current internal format. This change introduces support for scenario labels and source scenario version IDs in newer API versions, and automatically adapts dictionary parameters in the scenario graph during migration to ensure compatibility between environments.

designer/server/src/main/scala/pl/touk/nussknacker/ui/migrations · high confidence

Added DeploymentManagerStub for testing; Added Flink test suite for default model Kafka scenarios; Added OAuth2 test configuration for admin role validation; Added OpenAPI integration test resources; Added SQL enricher test utilities for HSQLDB and PostgreSQL; Added benchmark suite for Flink streaming, interpreter, serialization, and SpEL performance; Added comprehensive test coverage for Lite Kafka components; Added example scenario definitions and test infrastructure for E2E testing; Added in-memory test repositories for periodic process scheduling; Added integration and unit tests for periodic process service; Added integration tests for Designer API endpoints; Added integration tests for custom HTTP services; Added integration tests for database initialization and migration logic; Added integration tests for flow, dict, and scenario validation; Added integration tests for fragment repository operations; Added integration tests for scenario activity assertions; Added integration tests for scenario testing API capabilities; Added integration tests for the Scenario Live Data API HTTP service; Added local development environment runner for Nu Designer; Added snapshot tests for CountsRangesButtons and node reducer; Added snapshot tests for ProcessStateIcon component; Added test configuration files for business-case scenarios; Added test configuration for Designer server; Added test configuration for access control and scenario categories; Added test coverage for API components; Added test coverage for Flink engine components and Table API; Added test coverage for component grouping, usage tracking, and dynamic provider logic; Added test coverage for scenario process services and toolbar configuration; Added test coverage for scenario testing data structures and serialization; Added test coverage for test case assertion logic; Added test generators for Nussknacker graph nodes; Added test hooks for the testing toolbar; Added test mocks for the activities panel and related utilities; Added test resources for OAuth2 user roles and encryption; Added test resources for extra scripts validation; Added test service provider registrations for UI configuration and custom HTTP services; Added test utility for managing Apache Ignite database instances; Added tests for CachingProcessStateDeploymentManager; Added tests for Decision Table component validation and execution; Added tests for ExtraScriptsListingPreparer; Added tests for Flink periodic scenario scheduling and deployment; Added tests for HTTP client forbidden host and CIDR blocking; Added tests for High Availability leadership and distributed locking; Added tests for OpenAPI enricher configuration, security, and error handling; Added tests for ProcessProperties construction and conversion; Added tests for ProcessStateIcon component; Added tests for SQL enricher service behavior; Added tests for ScenarioGraph JSON encoding and legacy format decoding; Added tests for TestCaseValidator validation logic; Added tests for component definition extraction and edge type preparation; Added tests for configuration loading and processing type configs; Added tests for database migration scripts; Added tests for default model migration logic; Added tests for deployment repository and service logic; Added tests for deployment service and state consistency; Added tests for deployment state definition and status DTOs; Added tests for migration API versioning and scenario testing DTOs; Added tests for process marshalling and canonical conversion; Added tests for process migration and remote environment handling; Added tests for process node counting logic; Added tests for process repository and periodic scheduling logic; Added tests for processing type data and scenario parameters; Added tests for request-response collect transformer and JSON schema parameter generation; Added tests for runtime config extraction with dictionary editors; Added tests for scenario graph comparison, API version adaptation, PDF export, and utility classes; Added tests for scenario property and UI process validation; Added tests for scenario property validator and editor determination logic; Added tests for scenario test data serialization and service capabilities; Added tests for scenario toolbar configuration parsing; Added tests for the new test data format handler components; Added tests for the notification service; Added tests for usage statistics collection and reporting; Added tests for validation error formatting; Added unit tests for OpenAPI parameter extraction and request building; Added unit tests for designer client components and utilities; Added unit tests for fragment input definition components; Added unit tests for node modal expression editors; Added unit tests for the OpenAPI Swagger parser; Added validation for scenario-level test cases; Migrate Cypress support files to TypeScript and add new testing utilities; New Flink deployment manager integration tests and configuration; New Lite Components Testkit for Scenario Testing; New OpenAPI integration tests for service invocation and scenario enrichment; New TestKit abstractions for node compilation and scenario execution; New and updated end-to-end tests for the designer client; New integration test base traits for the Designer server; New integration tests for Lite Kafka and Request-Response runtime binaries; New shared test infrastructure for database-backed tests; New test configuration traits for designer scenarios; New test infrastructure API for service invocation and data handling; New test result UI components in the node modal; New test utilities for configuration validation, OpenAPI schema validation, and statistics encryption; New test utilities for mocking deployment and process repositories; New test utility library for scenario domain testing.

The Nussknacker Designer client dependencies have been updated, including React to 18.3.1, Redux Toolkit to 2.8.2, MUI to 5.16.14, and Ace Editor to 1.34.2. The build system has also been upgraded to use sbt 1.11.7 and Scala 2.13.18, ensuring compatibility with modern tooling and security patches.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 45 → 50 (+5.3)
• Rubric changed (rubric-2026.09.8 → rubric-2026.09.16) — scores are not directly comparable.

• Code Health 73 → 73 (+0.2)
• Architecture 52 → 48 (-3.4)
• Maturity 69 → 69 (-0.1)
• Readiness 52 → 48 (-4.2)
• Security 63 → 67 (+4.1)
• Accessibility 31 → 45 (+14.1)
• Performance 100 (new)

• Critical CVE: [CVE redacted] (designer/submodules/package-lock.json)
• Critical CVE: [GHSA redacted] (designer/client/package-lock.json)
• Critical CVE: [GHSA redacted] (designer/client/package-lock.json)
• Documentation: no installation or build instructions (README.md)
• High CVE: [CVE redacted] (designer/client/package-lock.json)
• High CVE: [CVE redacted] (designer/client/package-lock.json)
• High CVE: [CVE redacted] (designer/client/package-lock.json)
• High CVE: [CVE redacted] (designer/client/package-lock.json)
• High CVE: [CVE redacted] (designer/client/package-lock.json)
• High CVE: [CVE redacted] (designer/submodules/package-lock.json)
• High CVE: [CVE redacted] (designer/client/package-lock.json)
• High CVE: [CVE redacted] (designer/client/package-lock.json)
• High CVE: [CVE redacted] (designer/submodules/package-lock.json)
• High CVE: [CVE redacted] (designer/client/package-lock.json)
• High CVE: [CVE redacted] (designer/client/package-lock.json)
• High CVE: [CVE redacted] (designer/submodules/package-lock.json)
• High CVE: [CVE redacted] (designer/client/package-lock.json)
• High CVE: [CVE redacted] (designer/submodules/package-lock.json)
• High CVE: [CVE redacted] (designer/client/package-lock.json)
• High CVE: [CVE redacted] (designer/submodules/package-lock.json)
• …and 178 more

• Critical CVE: [GHSA redacted] (designer/client/package-lock.json)
• Critical CVE: [GHSA redacted] (designer/client/package-lock.json)
• Documentation: no project overview (README.md)
• Documentation: no project overview (docs/integrations/openAPI.md)
• Duplicated block (5 lines × 2) (scenario-compiler/src/main/java/pl/touk/nussknacker/engine/spel/SpelReflectionHelper.java)
• High CVE: [GHSA redacted] (designer/client/package-lock.json)
• High CVE: [GHSA redacted] (designer/client/package-lock.json)
• High CVE: [GHSA redacted] (designer/client/package-lock.json)
• High CVE: [GHSA redacted] (designer/client/package-lock.json)
• High CVE: [GHSA redacted] (designer/client/package-lock.json)
• High CVE: [GHSA redacted] (designer/client/package-lock.json)
• High CVE: [GHSA redacted] (designer/client/package-lock.json)
• High CVE: [GHSA redacted] (designer/client/package-lock.json)
• High CVE: [GHSA redacted] (designer/client/package-lock.json)
• High CVE: [GHSA redacted] (designer/client/package-lock.json)
• High CVE: [GHSA redacted] (designer/client/package-lock.json)
• High CVE: [GHSA redacted] (designer/client/package-lock.json)
• High CVE: [GHSA redacted] (designer/client/package-lock.json)
• High CVE: [GHSA redacted] (designer/client/package-lock.json)
• High CVE: [GHSA redacted] (designer/submodules/package-lock.json)
• …and 66 more

• 3 commits — 1 feature/other, 2 fixes

• designer/submodules — 1 commit
• engine/flink — 1 commit
• scenario-compiler/src — 1 commit

• fix: Fix parsing of SpEL template expressions in Variable (#153)
• fix: Fix scenarios failing on a null aggregateBy (#124) (#9472)
• change: Show two component links as icons without a menu (#9467)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

TouK/nussknacker was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.