Skip to content
Weik.ioDocs
2026.1
Try Weik.io

This page describes Weik.io 2026.1, and the current release is 2026.2. Weik.io 2026.2 docs

Plugins

Weik.io 2026.1

Extend Weik.io with custom functionality via NuGet packages.

On this page

Plugins extend Weik.io with custom functionality delivered as standard .NET NuGet packages. You can build, package, and deploy custom integrations, components, and features.

What are plugins?#

Plugins are .NET NuGet packages that add functionality to Weik.io:

  • Custom integration flows
  • New data connectors
  • Custom transformations
  • Webjobs and background services
  • API endpoints
  • UI components

Key features#

  • NuGet-based: Standard .NET package format
  • Version management: Track and manage plugin versions
  • Hot reload: Update plugins without restarting
  • Dependency management: Automatic dependency resolution
  • Security: Sandboxed execution
  • Discovery: Browse available plugins

Plugin types#

Integration flows#

Package integration flows as plugins:

IntegrationFlow.CustomerSync.1.0.0.nupkg

Deployed flows appear in Integrations > Flows.

Webjobs#

Package background jobs:

Webjob.MessageProcessor.2.0.0.nupkg

Deployed webjobs appear in Automation > Webjobs.

Components#

Custom integration components:

Components.SAPConnector.1.5.0.nupkg

Components can be used in integration flows.

Transformers#

Custom data transformations:

Transformers.CustomMapper.1.0.0.nupkg

Transformers are available in transformation steps.

Creating plugins#

Plugin project structure#

MyPlugin/
├── MyPlugin.csproj
├── Plugin.cs
├── README.md
└── appsettings.json

Basic plugin#

<!-- MyPlugin.csproj -->
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <PackageId>MyCompany.MyPlugin</PackageId>
    <Version>1.0.0</Version>
    <Authors>My Company</Authors>
    <Description>Custom plugin for Weik.io</Description>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Weikio.PluginFramework" Version="2.0.0" />
  </ItemGroup>
</Project>
// Plugin.cs
using Weikio.PluginFramework;

namespace MyCompany.MyPlugin
{
    public class MyPlugin : IPlugin
    {
        public string Name => "My Custom Plugin";
        public string Version => "1.0.0";

        public Task Initialize()
        {
            // Plugin initialization logic
            return Task.CompletedTask;
        }

        public Task Execute(PluginContext context)
        {
            // Plugin execution logic
            return Task.CompletedTask;
        }
    }
}

Building plugins#

Terminal
# Build and package
dotnet pack -c Release

# Output: bin/Release/MyCompany.MyPlugin.1.0.0.nupkg

Uploading plugins#

Via UI#

  1. Navigate to Plugins > Overview
  2. Click the Upload… button
  3. Select the .nupkg file
  4. The plugin is uploaded and registered
  5. The plugin is available for use immediately

Via CLI#

Terminal
weikio plugin upload MyPlugin.1.0.0.nupkg

Via API#

Terminal
curl -X POST https://weik.io/api/plugins/upload \
  -H "Authorization: Bearer ${TOKEN}" \
  -F "package=@MyPlugin.1.0.0.nupkg"

Managing plugins#

Viewing plugins#

The Plugins page displays:

  • Plugin ID: Package identifier
  • Plugin Version: Current version
  • Actions: View details, delete

Plugin details#

View plugin information:

  • Package metadata
  • Dependencies
  • Versions available
  • Usage across integrations

Updating plugins#

Upload a new version:

  1. Build a new version with an incremented version number
  2. Upload the new .nupkg file
  3. Update integrations to use the new version

Deleting plugins#

Remove plugins:

  1. Ensure no integrations use the plugin
  2. Click delete on the plugin
  3. Confirm the deletion
  4. The package is removed

Integration flow plugins#

Creating a flow plugin#

# flow.yaml
apiVersion: weik.io/v1alpha1
kind: IntegrationFlow
metadata:
  name: customer-sync
  version: 1.0.0
spec:
  source:
    uri: "timer:sync?period=300000"

  steps:
    - uri: "http://api.example.com/customers"
    - to: "database:customers"

Package configuration#

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <PackageId>IntegrationFlow.CustomerSync</PackageId>
    <Version>1.0.0</Version>
  </PropertyGroup>

  <ItemGroup>
    <None Include="flow.yaml" Pack="true" PackagePath="/" />
  </ItemGroup>
</Project>

Component plugins#

Custom connector#

using Weikio.PluginFramework;

namespace MyCompany.Connectors
{
    public class SalesforceConnector : IConnector
    {
        public async Task<T> GetAsync<T>(string resourceId)
        {
            // Salesforce API call
            var client = new SalesforceClient();
            return await client.GetAsync<T>(resourceId);
        }

        public async Task CreateAsync<T>(T resource)
        {
            // Salesforce API call
            var client = new SalesforceClient();
            await client.CreateAsync(resource);
        }
    }
}

Transformation plugins#

Custom transformer#

using Weikio.PluginFramework;

namespace MyCompany.Transformers
{
    public class CustomMapper : ITransformer
    {
        public async Task<object> TransformAsync(object input, TransformContext context)
        {
            // Custom transformation logic
            var sourceData = (SourceModel)input;

            var transformed = new DestinationModel
            {
                Id = sourceData.SourceId,
                Name = TransformName(sourceData),
                // ... mapping logic
            };

            return transformed;
        }

        private string TransformName(SourceModel source)
        {
            // Custom transformation
            return $"{source.FirstName} {source.LastName}";
        }
    }
}

Plugin dependencies#

Referencing other packages#

<ItemGroup>
  <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
  <PackageReference Include="Dapper" Version="2.1.0" />
  <PackageReference Include="RestSharp" Version="110.2.0" />
</ItemGroup>

Dependencies are automatically resolved and loaded.

Plugin-to-plugin dependencies#

<ItemGroup>
  <PackageReference Include="MyCompany.SharedLib" Version="1.0.0" />
</ItemGroup>

Plugin configuration#

appsettings.json#

{
  "MyPlugin": {
    "ApiEndpoint": "https://api.example.com",
    "Timeout": 30,
    "RetryCount": 3
  }
}

Using variables#

public class ConfigurablePlugin : IPlugin
{
    private readonly IConfiguration _config;

    public ConfigurablePlugin(IConfiguration config)
    {
        _config = config;
    }

    public Task Execute(PluginContext context)
    {
        var apiKey = _config["MyPlugin:ApiKey"];
        var endpoint = _config["MyPlugin:ApiEndpoint"];

        // Use configuration
        return Task.CompletedTask;
    }
}

Security#

Sandboxing#

Plugins run in a sandboxed environment:

  • Limited file system access
  • Restricted network access
  • Controlled resource usage
  • Isolated from other plugins

Code signing#

Sign plugins for verification:

Terminal
# Sign package
nuget sign MyPlugin.1.0.0.nupkg \
  -CertificatePath cert.pfx \
  -Timestamper http://timestamp.digicert.com

Permissions#

Control plugin capabilities:

<PropertyGroup>
  <PluginPermissions>FileSystem;Network;Database</PluginPermissions>
</PropertyGroup>

Best practices#

Version properly

  • Use semantic versioning
  • Increment appropriately for changes
  • Maintain backward compatibility

Document thoroughly

  • Include a README in the package
  • Document configuration options
  • Provide usage examples
  • List dependencies and requirements

Test before upload

  • Test in a development environment
  • Verify dependencies load correctly
  • Test error scenarios
  • Performance test with realistic data

Handle errors gracefully

public async Task Execute(PluginContext context)
{
    try
    {
        // Plugin logic
    }
    catch (Exception ex)
    {
        context.Logger.LogError(ex, "Plugin execution failed");
        throw new PluginException("Execution failed", ex);
    }
}

Use dependency injection

public class MyPlugin : IPlugin
{
    private readonly ILogger<MyPlugin> _logger;
    private readonly IConfiguration _config;

    public MyPlugin(ILogger<MyPlugin> logger, IConfiguration config)
    {
        _logger = logger;
        _config = config;
    }
}

Troubleshooting#

Plugin does not load

  • Check the package format
  • Verify dependencies are available
  • Review upload logs
  • Check compatibility with the Weik.io version

Plugin errors at runtime

  • Review plugin logs
  • Check configuration
  • Verify permissions
  • Test dependencies

Version conflicts

  • Check dependency versions
  • Review other loaded plugins
  • Use binding redirects if needed

Plugin marketplace#

Browse available plugins:

  • Official Weik.io plugins
  • Community plugins
  • Enterprise plugins
  • Custom company plugins

Integration with other features#

Plugins integrate with:

  • Integration Flows: Custom flow plugins
  • Webjobs: Background job plugins
  • Automation: Custom action plugins
  • Data APIs: Custom connector plugins
  • Agents: Distributed plugin execution

Next steps#