my-plugin/
├── src/main/java/
│   └── com/company/plugin/
│       ├── MyConnector.groovy
│       └── DSLComponent.groovy
└── build.gradle

plugins {
    id 'groovy'
    id 'biz.aQute.bnd.builder' version '7.1.0'
}

dependencies {
    // Hub Plugin SDK
    implementation 'com.zenoo.hub:hub-plugin-sdk:1.0.0'

    // Testing
    testImplementation 'org.spockframework:spock-core:2.3-groovy-3.0'
    testImplementation 'org.mockito:mockito-core:4.8.0'
}

// OSGI Bundle Configuration
jar {
    manifest {
        attributes(
                'Bundle-SymbolicName': 'my-plugin',
                'Bundle-Version': '0.1.0',
                'Service-Component': '*'
        )
    }
}

package com.company.plugin

import com.zenoo.hub.dsl.attribute.Attribute
import com.zenoo.hub.dsl.attribute.AttributeBuilder
import com.zenoo.hub.plugin.sdk.Connector
import groovy.util.logging.Slf4j
import org.osgi.service.component.annotations.Component
import reactor.core.publisher.Mono

@Slf4j
@Component(immediate = true)
class MyConnector implements Connector {

    @Override
    String name() {
        return 'my-plugin'
    }

    @Override
    Mono<Attribute> exchange(Attribute input) {
        log.info("Processing input: {}", input)
         // Return result
         return Mono.just(AttributeBuilder.of([
             processed: input,
             timestamp: System.currentTimeMillis(),
             success: true,
             plugin: name()
         ]))
    }

}

package com.company.plugin

import com.zenoo.hub.plugin.sdk.ComponentBuilder
import com.zenoo.hub.plugin.sdk.ComponentFactory
import org.osgi.service.component.annotations.Component

@Component
class MyPluginDSLComponent implements ComponentFactory {

    @Override
    ComponentBuilder define() {
        return ComponentBuilder.component {
            dependencies {
                connector 'my-plugin'
            }

            // Exposed function accessible via Client API
            exposed('process-data') {
                payload ->
                    function('validate-input') {
                        input payload
                        namespace validated
                    }

                    exchange('process') {
                        connector 'my-plugin'
                        config validated
                    }.orError {
                       error([error: 'Processing failed', timestamp: System.currentTimeMillis()])
                    }
            }

            // Reusable workflow
            workflow('document-processing') {
                route('upload') {
                    uri '/plugin/upload'
                    validate {
                        required 'document'
                        optional 'options'
                    }
                }

                function('process-document') {
                    input payload
                    namespace result
                }

                route('results') {
                    uri '/plugin/results'
                    export data: result
                    terminal()
                }
            }

            // Reusable function
            function('validate-input') {
                input ->
                    mapper('input-mapper') {
                        payload -> [
                            data: payload.data,
                            isValid: payload.data != null,
                            timestamp: System.currentTimeMillis()
                        ]
                    }
            }

            // Data mapper
            mapper('input-mapper') {
                payload -> [
                    data: payload.data,
                    isValid: payload.data != null,
                    timestamp: System.currentTimeMillis()
                ]
            }
        }
    }
}