diff --git a/.specify/feature.json b/.specify/feature.json index d418d5e78..1c74f069f 100644 --- a/.specify/feature.json +++ b/.specify/feature.json @@ -1,3 +1,3 @@ { - "feature_directory": "specs/008-diagnostics-otel" + "feature_directory": "specs/010-workflow-json-hardening" } diff --git a/AGENTS.md b/AGENTS.md index 62610a8e8..3390d955c 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -83,7 +83,7 @@ Before handing off changes, verify the following when applicable: For additional context about technologies to be used, project structure, -shell commands, and other important information, read `specs/008-diagnostics-otel/plan.md`. +shell commands, and other important information, read `specs/010-workflow-json-hardening/plan.md`. ## Active Technologies diff --git a/Elsa.sln b/Elsa.sln index 46a604192..2fc20c983 100644 --- a/Elsa.sln +++ b/Elsa.sln @@ -1,4 +1,4 @@ - + Microsoft Visual Studio Solution File, Format Version 12.00 # Visual Studio Version 17 VisualStudioVersion = 17.7.34003.232 @@ -347,11 +347,11 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Elsa.Secrets.UnitTests", "t EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Elsa.Workflows.Api.UnitTests", "test\unit\Elsa.Workflows.Api.UnitTests\Elsa.Workflows.Api.UnitTests.csproj", "{81CFD2E0-2E5E-4810-ADB8-A08301199166}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Elsa.Diagnostics.OpenTelemetry", "src\modules\Elsa.Diagnostics.OpenTelemetry\Elsa.Diagnostics.OpenTelemetry.csproj", "{007E3396-34EE-40A8-B697-23D694DC9EBE}" +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Elsa.Diagnostics.OpenTelemetry", "src\modules\Elsa.Diagnostics.OpenTelemetry\Elsa.Diagnostics.OpenTelemetry.csproj", "{8F4AD54E-8586-4D8C-82E6-69218DD4280F}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Elsa.Diagnostics.OpenTelemetry.UnitTests", "test\unit\Elsa.Diagnostics.OpenTelemetry.UnitTests\Elsa.Diagnostics.OpenTelemetry.UnitTests.csproj", "{D9D6C168-36CB-46EB-838A-B26C22FE9FDB}" +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Elsa.Diagnostics.OpenTelemetry.UnitTests", "test\unit\Elsa.Diagnostics.OpenTelemetry.UnitTests\Elsa.Diagnostics.OpenTelemetry.UnitTests.csproj", "{60F844CC-6DA6-45EB-BA5E-B480B4E77624}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Elsa.Diagnostics.OpenTelemetry.IntegrationTests", "test\integration\Elsa.Diagnostics.OpenTelemetry.IntegrationTests\Elsa.Diagnostics.OpenTelemetry.IntegrationTests.csproj", "{B5075CE7-7332-4F78-AB3D-492D670789FB}" +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Elsa.Diagnostics.OpenTelemetry.IntegrationTests", "test\integration\Elsa.Diagnostics.OpenTelemetry.IntegrationTests\Elsa.Diagnostics.OpenTelemetry.IntegrationTests.csproj", "{B6A62D42-D9AA-47BE-BCBC-FCB866D346F0}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution @@ -1393,42 +1393,42 @@ Global {81CFD2E0-2E5E-4810-ADB8-A08301199166}.Release|x64.Build.0 = Release|Any CPU {81CFD2E0-2E5E-4810-ADB8-A08301199166}.Release|x86.ActiveCfg = Release|Any CPU {81CFD2E0-2E5E-4810-ADB8-A08301199166}.Release|x86.Build.0 = Release|Any CPU - {007E3396-34EE-40A8-B697-23D694DC9EBE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {007E3396-34EE-40A8-B697-23D694DC9EBE}.Debug|Any CPU.Build.0 = Debug|Any CPU - {007E3396-34EE-40A8-B697-23D694DC9EBE}.Debug|x64.ActiveCfg = Debug|Any CPU - {007E3396-34EE-40A8-B697-23D694DC9EBE}.Debug|x64.Build.0 = Debug|Any CPU - {007E3396-34EE-40A8-B697-23D694DC9EBE}.Debug|x86.ActiveCfg = Debug|Any CPU - {007E3396-34EE-40A8-B697-23D694DC9EBE}.Debug|x86.Build.0 = Debug|Any CPU - {007E3396-34EE-40A8-B697-23D694DC9EBE}.Release|Any CPU.ActiveCfg = Release|Any CPU - {007E3396-34EE-40A8-B697-23D694DC9EBE}.Release|Any CPU.Build.0 = Release|Any CPU - {007E3396-34EE-40A8-B697-23D694DC9EBE}.Release|x64.ActiveCfg = Release|Any CPU - {007E3396-34EE-40A8-B697-23D694DC9EBE}.Release|x64.Build.0 = Release|Any CPU - {007E3396-34EE-40A8-B697-23D694DC9EBE}.Release|x86.ActiveCfg = Release|Any CPU - {007E3396-34EE-40A8-B697-23D694DC9EBE}.Release|x86.Build.0 = Release|Any CPU - {D9D6C168-36CB-46EB-838A-B26C22FE9FDB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {D9D6C168-36CB-46EB-838A-B26C22FE9FDB}.Debug|Any CPU.Build.0 = Debug|Any CPU - {D9D6C168-36CB-46EB-838A-B26C22FE9FDB}.Debug|x64.ActiveCfg = Debug|Any CPU - {D9D6C168-36CB-46EB-838A-B26C22FE9FDB}.Debug|x64.Build.0 = Debug|Any CPU - {D9D6C168-36CB-46EB-838A-B26C22FE9FDB}.Debug|x86.ActiveCfg = Debug|Any CPU - {D9D6C168-36CB-46EB-838A-B26C22FE9FDB}.Debug|x86.Build.0 = Debug|Any CPU - {D9D6C168-36CB-46EB-838A-B26C22FE9FDB}.Release|Any CPU.ActiveCfg = Release|Any CPU - {D9D6C168-36CB-46EB-838A-B26C22FE9FDB}.Release|Any CPU.Build.0 = Release|Any CPU - {D9D6C168-36CB-46EB-838A-B26C22FE9FDB}.Release|x64.ActiveCfg = Release|Any CPU - {D9D6C168-36CB-46EB-838A-B26C22FE9FDB}.Release|x64.Build.0 = Release|Any CPU - {D9D6C168-36CB-46EB-838A-B26C22FE9FDB}.Release|x86.ActiveCfg = Release|Any CPU - {D9D6C168-36CB-46EB-838A-B26C22FE9FDB}.Release|x86.Build.0 = Release|Any CPU - {B5075CE7-7332-4F78-AB3D-492D670789FB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {B5075CE7-7332-4F78-AB3D-492D670789FB}.Debug|Any CPU.Build.0 = Debug|Any CPU - {B5075CE7-7332-4F78-AB3D-492D670789FB}.Debug|x64.ActiveCfg = Debug|Any CPU - {B5075CE7-7332-4F78-AB3D-492D670789FB}.Debug|x64.Build.0 = Debug|Any CPU - {B5075CE7-7332-4F78-AB3D-492D670789FB}.Debug|x86.ActiveCfg = Debug|Any CPU - {B5075CE7-7332-4F78-AB3D-492D670789FB}.Debug|x86.Build.0 = Debug|Any CPU - {B5075CE7-7332-4F78-AB3D-492D670789FB}.Release|Any CPU.ActiveCfg = Release|Any CPU - {B5075CE7-7332-4F78-AB3D-492D670789FB}.Release|Any CPU.Build.0 = Release|Any CPU - {B5075CE7-7332-4F78-AB3D-492D670789FB}.Release|x64.ActiveCfg = Release|Any CPU - {B5075CE7-7332-4F78-AB3D-492D670789FB}.Release|x64.Build.0 = Release|Any CPU - {B5075CE7-7332-4F78-AB3D-492D670789FB}.Release|x86.ActiveCfg = Release|Any CPU - {B5075CE7-7332-4F78-AB3D-492D670789FB}.Release|x86.Build.0 = Release|Any CPU + {8F4AD54E-8586-4D8C-82E6-69218DD4280F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {8F4AD54E-8586-4D8C-82E6-69218DD4280F}.Debug|Any CPU.Build.0 = Debug|Any CPU + {8F4AD54E-8586-4D8C-82E6-69218DD4280F}.Debug|x64.ActiveCfg = Debug|Any CPU + {8F4AD54E-8586-4D8C-82E6-69218DD4280F}.Debug|x64.Build.0 = Debug|Any CPU + {8F4AD54E-8586-4D8C-82E6-69218DD4280F}.Debug|x86.ActiveCfg = Debug|Any CPU + {8F4AD54E-8586-4D8C-82E6-69218DD4280F}.Debug|x86.Build.0 = Debug|Any CPU + {8F4AD54E-8586-4D8C-82E6-69218DD4280F}.Release|Any CPU.ActiveCfg = Release|Any CPU + {8F4AD54E-8586-4D8C-82E6-69218DD4280F}.Release|Any CPU.Build.0 = Release|Any CPU + {8F4AD54E-8586-4D8C-82E6-69218DD4280F}.Release|x64.ActiveCfg = Release|Any CPU + {8F4AD54E-8586-4D8C-82E6-69218DD4280F}.Release|x64.Build.0 = Release|Any CPU + {8F4AD54E-8586-4D8C-82E6-69218DD4280F}.Release|x86.ActiveCfg = Release|Any CPU + {8F4AD54E-8586-4D8C-82E6-69218DD4280F}.Release|x86.Build.0 = Release|Any CPU + {60F844CC-6DA6-45EB-BA5E-B480B4E77624}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {60F844CC-6DA6-45EB-BA5E-B480B4E77624}.Debug|Any CPU.Build.0 = Debug|Any CPU + {60F844CC-6DA6-45EB-BA5E-B480B4E77624}.Debug|x64.ActiveCfg = Debug|Any CPU + {60F844CC-6DA6-45EB-BA5E-B480B4E77624}.Debug|x64.Build.0 = Debug|Any CPU + {60F844CC-6DA6-45EB-BA5E-B480B4E77624}.Debug|x86.ActiveCfg = Debug|Any CPU + {60F844CC-6DA6-45EB-BA5E-B480B4E77624}.Debug|x86.Build.0 = Debug|Any CPU + {60F844CC-6DA6-45EB-BA5E-B480B4E77624}.Release|Any CPU.ActiveCfg = Release|Any CPU + {60F844CC-6DA6-45EB-BA5E-B480B4E77624}.Release|Any CPU.Build.0 = Release|Any CPU + {60F844CC-6DA6-45EB-BA5E-B480B4E77624}.Release|x64.ActiveCfg = Release|Any CPU + {60F844CC-6DA6-45EB-BA5E-B480B4E77624}.Release|x64.Build.0 = Release|Any CPU + {60F844CC-6DA6-45EB-BA5E-B480B4E77624}.Release|x86.ActiveCfg = Release|Any CPU + {60F844CC-6DA6-45EB-BA5E-B480B4E77624}.Release|x86.Build.0 = Release|Any CPU + {B6A62D42-D9AA-47BE-BCBC-FCB866D346F0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {B6A62D42-D9AA-47BE-BCBC-FCB866D346F0}.Debug|Any CPU.Build.0 = Debug|Any CPU + {B6A62D42-D9AA-47BE-BCBC-FCB866D346F0}.Debug|x64.ActiveCfg = Debug|Any CPU + {B6A62D42-D9AA-47BE-BCBC-FCB866D346F0}.Debug|x64.Build.0 = Debug|Any CPU + {B6A62D42-D9AA-47BE-BCBC-FCB866D346F0}.Debug|x86.ActiveCfg = Debug|Any CPU + {B6A62D42-D9AA-47BE-BCBC-FCB866D346F0}.Debug|x86.Build.0 = Debug|Any CPU + {B6A62D42-D9AA-47BE-BCBC-FCB866D346F0}.Release|Any CPU.ActiveCfg = Release|Any CPU + {B6A62D42-D9AA-47BE-BCBC-FCB866D346F0}.Release|Any CPU.Build.0 = Release|Any CPU + {B6A62D42-D9AA-47BE-BCBC-FCB866D346F0}.Release|x64.ActiveCfg = Release|Any CPU + {B6A62D42-D9AA-47BE-BCBC-FCB866D346F0}.Release|x64.Build.0 = Release|Any CPU + {B6A62D42-D9AA-47BE-BCBC-FCB866D346F0}.Release|x86.ActiveCfg = Release|Any CPU + {B6A62D42-D9AA-47BE-BCBC-FCB866D346F0}.Release|x86.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE @@ -1552,9 +1552,9 @@ Global {09B4B78B-FE02-44E2-8667-E182AF921C54} = {5BA4A8FA-F7F4-45B3-AEC8-8886D35AAC79} {7D905CEC-B30B-4C99-B5F7-3052D33EC8E9} = {18453B51-25EB-4317-A4B3-B10518252E92} {81CFD2E0-2E5E-4810-ADB8-A08301199166} = {18453B51-25EB-4317-A4B3-B10518252E92} - {D9D6C168-36CB-46EB-838A-B26C22FE9FDB} = {18453B51-25EB-4317-A4B3-B10518252E92} - {B5075CE7-7332-4F78-AB3D-492D670789FB} = {1B8D5897-902E-4632-8698-E89CAF3DDF54} - {007E3396-34EE-40A8-B697-23D694DC9EBE} = {78FD90A4-90A5-445F-97F2-74BA835AFA5D} + {8F4AD54E-8586-4D8C-82E6-69218DD4280F} = {5BA4A8FA-F7F4-45B3-AEC8-8886D35AAC79} + {60F844CC-6DA6-45EB-BA5E-B480B4E77624} = {18453B51-25EB-4317-A4B3-B10518252E92} + {B6A62D42-D9AA-47BE-BCBC-FCB866D346F0} = {1B8D5897-902E-4632-8698-E89CAF3DDF54} EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {D4B5CEAA-7D70-4FCB-A68E-B03FBE5E0E5E} diff --git a/doc/wiki/workflow-core.md b/doc/wiki/workflow-core.md index 83707c568..c82a48106 100644 --- a/doc/wiki/workflow-core.md +++ b/doc/wiki/workflow-core.md @@ -148,6 +148,14 @@ Core serializers live under [Serialization](../../src/modules/Elsa.Workflows.Cor Custom constructor and additional converter configurators are registered by `WorkflowsFeature`. +### Workflow JSON Type Identifiers + +Workflow JSON type resolution uses the shared `ISerializationTypeRegistry` from `Elsa.Common.Serialization`, not expression type aliases. Register workflow-serializable payload types through `SerializationTypeOptions`; keep `ExpressionOptions` for expression/type metadata only. + +New workflow JSON writes preferred aliases when a type is registered. Compatibility reads also accept explicitly registered legacy names, including selected CLR names from older persisted workflow JSON. Unknown CLR names are rejected rather than loaded dynamically. Polymorphic object reads also reject abstract, interface, open generic, and unsupported collection targets unless the resolver can map a known collection interface to a concrete collection type. + +Public API payloads that expose workflow JSON type identifiers should emit values from `ISerializationTypeRegistry`. For example, incident strategy descriptors return the alias that workflow JSON accepts, while registered legacy CLR names remain readable during the compatibility window. + ## When To Change This Layer Change workflow core only when you are changing engine semantics, activity contracts, execution state, serialization, core activity behavior, or flowchart behavior. If the change is about persisted definitions, API DTOs, background dispatch, or a module-specific transport, start in management, API, runtime, or the extension module instead. diff --git a/specs/010-workflow-json-hardening/checklists/requirements.md b/specs/010-workflow-json-hardening/checklists/requirements.md new file mode 100644 index 000000000..9a990910a --- /dev/null +++ b/specs/010-workflow-json-hardening/checklists/requirements.md @@ -0,0 +1,34 @@ +# Specification Quality Checklist: Workflow JSON Type Hardening + +**Purpose**: Validate specification completeness and quality before proceeding to planning +**Created**: 2026-05-29 +**Feature**: [spec.md](../spec.md) + +## Content Quality + +- [x] No implementation details (languages, frameworks, APIs) +- [x] Focused on user value and business needs +- [x] Written for non-technical stakeholders +- [x] All mandatory sections completed + +## Requirement Completeness + +- [x] No [NEEDS CLARIFICATION] markers remain +- [x] Requirements are testable and unambiguous +- [x] Success criteria are measurable +- [x] Success criteria are technology-agnostic (no implementation details) +- [x] All acceptance scenarios are defined +- [x] Edge cases are identified +- [x] Scope is clearly bounded +- [x] Dependencies and assumptions identified + +## Feature Readiness + +- [x] All functional requirements have clear acceptance criteria +- [x] User scenarios cover primary flows +- [x] Feature meets measurable outcomes defined in Success Criteria +- [x] No implementation details leak into specification + +## Notes + +- Validation passed. The issue explicitly requires a dedicated workflow serialization type registry or resolver; the specification names this capability as a required product behavior while deferring implementation details to planning. diff --git a/specs/010-workflow-json-hardening/contracts/workflow-json-type-identifiers.md b/specs/010-workflow-json-hardening/contracts/workflow-json-type-identifiers.md new file mode 100644 index 000000000..2e39ff815 --- /dev/null +++ b/specs/010-workflow-json-hardening/contracts/workflow-json-type-identifiers.md @@ -0,0 +1,15 @@ +# Contract: Workflow JSON Type Identifiers + +## Identifier Rules + +- New workflow JSON writes aliases when a type is registered with a workflow JSON alias. +- Compatibility reads accept registered aliases and registered legacy names. +- Unknown CLR names are rejected. +- Abstract, interface, open generic, and inappropriate collection targets are rejected for polymorphic object materialization. +- Supported collection aliases are limited to known collection wrappers closed over registered element types. + +## Incident Strategy Descriptor + +`GET /descriptors/incident-strategies` returns `typeName` values from the shared serialization type registry. + +Clients should persist or submit returned `typeName` values unchanged. During the compatibility window, existing CLR names registered as legacy identifiers remain accepted when workflow JSON is read. diff --git a/specs/010-workflow-json-hardening/data-model.md b/specs/010-workflow-json-hardening/data-model.md new file mode 100644 index 000000000..1782d97ec --- /dev/null +++ b/specs/010-workflow-json-hardening/data-model.md @@ -0,0 +1,20 @@ +# Data Model: Workflow JSON Type Hardening + +## SerializationTypeOptions + +- Stores workflow JSON aliases mapped to concrete types. +- Stores optional legacy names mapped to the same concrete types. +- Provides default primitive and JSON island aliases needed by workflow payloads. +- Lives in `Elsa.Common` so non-workflow serialization layers can share the same trust boundary. + +## SerializationTypeRegistry + +- Runtime registry built from `SerializationTypeOptions`. +- Resolves aliases and registered legacy names to types. +- Lists registered types for compatibility resolution. +- Returns preferred aliases for writing new workflow JSON and public descriptor values. + +## Workflow Type Identifier + +- Alias: preferred stable identifier for new workflow JSON. +- Legacy name: supported compatibility identifier for previously persisted workflow JSON or older clients. diff --git a/specs/010-workflow-json-hardening/plan.md b/specs/010-workflow-json-hardening/plan.md new file mode 100644 index 000000000..d68f63df0 --- /dev/null +++ b/specs/010-workflow-json-hardening/plan.md @@ -0,0 +1,88 @@ +# Implementation Plan: Workflow JSON Type Hardening + +**Branch**: `codex/7541-workflow-json-hardening` | **Date**: 2026-05-29 | **Spec**: [spec.md](spec.md) +**Input**: Feature specification from `/specs/010-workflow-json-hardening/spec.md` + +**Note**: This template is filled in by the `/speckit-plan` command. See `.specify/templates/plan-template.md` for the execution workflow. + +## Summary + +Reintroduce workflow JSON hardening through a workflow-specific type registry and resolver. Existing registered legacy CLR names remain readable, new workflow JSON emits aliases when available, and public descriptor APIs use the same identifier contract they accept. + +## Technical Context + + + +**Language/Version**: C# latest with nullable reference types, multi-targeting through existing project settings +**Primary Dependencies**: System.Text.Json, Elsa feature/module infrastructure, existing expression registry for expression-only behavior +**Storage**: Existing workflow JSON payloads only; no schema changes +**Testing**: Targeted `dotnet test` for workflow core/runtime/api test projects +**Target Platform**: Elsa server/library consumers on supported .NET target frameworks +**Project Type**: Modular .NET library and API modules +**Performance Goals**: Type lookup remains dictionary-based and does not add reflection scans to normal serialization +**Constraints**: No arbitrary CLR type loading; compatibility only for explicitly registered workflow JSON legacy names +**Scale/Scope**: Workflow definitions, workflow state, trigger/bookmark payloads, incident strategy descriptor contract, and module/extension registrations + +## Constitution Check + +*GATE: Must pass before Phase 0 research. Re-check after Phase 1 design.* + +PASS. The change stays inside existing workflow modules, adds one explicit extensibility point for serialization trust, preserves public compatibility, and includes focused tests. No new persistence provider or unrelated module is introduced. + +## Project Structure + +### Documentation (this feature) + +```text +specs/[###-feature]/ +├── plan.md # This file (/speckit-plan command output) +├── research.md # Phase 0 output (/speckit-plan command) +├── data-model.md # Phase 1 output (/speckit-plan command) +├── quickstart.md # Phase 1 output (/speckit-plan command) +├── contracts/ # Phase 1 output (/speckit-plan command) +└── tasks.md # Phase 2 output (/speckit-tasks command - NOT created by /speckit-plan) +``` + +### Source Code (repository root) + + +```text +src/modules/Elsa.Workflows.Core/ +├── Contracts/ +├── Extensions/ +├── Options/ +├── Serialization/ +└── Features/ + +src/modules/Elsa.Workflows.Runtime/ +├── Features/ +├── ShellFeatures/ +└── Services/ + +src/modules/Elsa.Workflows.Api/ +└── Endpoints/IncidentStrategies/ + +test/unit/Elsa.Workflows.Core.UnitTests/ +test/unit/Elsa.Workflows.Runtime.UnitTests/ +test/integration/Elsa.Workflows.IntegrationTests/ +``` + +**Structure Decision**: Extend the existing workflow core serialization surface and update runtime/API registrations in place. Tests stay in the nearest existing workflow test projects. + +## Complexity Tracking + +> **Fill ONLY if Constitution Check has violations that must be justified** + +| Violation | Why Needed | Simpler Alternative Rejected Because | +|-----------|------------|-------------------------------------| +| [e.g., 4th project] | [current need] | [why 3 projects insufficient] | +| [e.g., Repository pattern] | [specific problem] | [why direct DB access insufficient] | diff --git a/specs/010-workflow-json-hardening/quickstart.md b/specs/010-workflow-json-hardening/quickstart.md new file mode 100644 index 000000000..9ea443ee7 --- /dev/null +++ b/specs/010-workflow-json-hardening/quickstart.md @@ -0,0 +1,11 @@ +# Quickstart: Workflow JSON Type Hardening + +1. Register built-in workflow JSON aliases through workflow features. +2. Register module payload aliases through each module that serializes workflow payloads. +3. Verify `TypeJsonConverter` and `PolymorphicObjectConverter` use the shared serialization registry, not expression options. +4. Run targeted tests: + +```sh +dotnet test test/unit/Elsa.Workflows.Core.UnitTests/Elsa.Workflows.Core.UnitTests.csproj --filter SerializationTypeResolverTests +dotnet test test/unit/Elsa.Workflows.Runtime.UnitTests/Elsa.Workflows.Runtime.UnitTests.csproj --filter WorkflowRuntimeFeatureTests +``` diff --git a/specs/010-workflow-json-hardening/research.md b/specs/010-workflow-json-hardening/research.md new file mode 100644 index 000000000..03c83d02f --- /dev/null +++ b/specs/010-workflow-json-hardening/research.md @@ -0,0 +1,25 @@ +# Research: Workflow JSON Type Hardening + +## Decision: Dedicated Workflow JSON Registry + +Use a workflow-specific registry and options object for `TypeJsonConverter`, `PolymorphicObjectConverter`, workflow state serialization, bookmark payload serialization, trigger comparison, hashing, and descriptor contracts. + +**Rationale**: The issue explicitly rejects using `ExpressionOptions` as the workflow JSON trust boundary. A dedicated registry makes the allowed workflow JSON surface explicit while leaving expression aliases available for expression evaluation and designer variable metadata. + +**Alternatives considered**: Reusing `IWellKnownTypeRegistry` was rejected because it is fed by `ExpressionOptions`. Direct `Type.GetType` fallback was rejected because it can load arbitrary CLR names. + +## Decision: Explicit Legacy Compatibility Names + +Compatibility reads accept aliases and registered legacy names, including simple assembly-qualified names, full assembly-qualified names for registered types, and supported collection wrappers over registered element types. + +**Rationale**: Existing persisted workflows may contain CLR names, but the trust boundary must be the registration list, not assembly probing. + +**Alternatives considered**: A broad assembly allow-list was rejected for this slice because it is harder to reason about and can accidentally expose unrelated types from trusted assemblies. + +## Decision: Alias-First Public Descriptor Contract + +Incident strategy descriptors should emit the workflow JSON alias for registered strategies while keeping legacy CLR names readable on input during the compatibility window. + +**Rationale**: The reported dropdown failure came from descriptors returning CLR names while hardened reads expected aliases. Emitting aliases aligns new clients with hardened serialization without breaking old payloads. + +**Alternatives considered**: Keeping CLR names in descriptors was rejected because it perpetuates the inconsistent contract. diff --git a/specs/010-workflow-json-hardening/spec.md b/specs/010-workflow-json-hardening/spec.md new file mode 100644 index 000000000..01ecff726 --- /dev/null +++ b/specs/010-workflow-json-hardening/spec.md @@ -0,0 +1,103 @@ +# Feature Specification: Workflow JSON Type Hardening + +**Feature Branch**: `codex/7541-workflow-json-hardening` +**Created**: 2026-05-29 +**Status**: Draft +**Input**: User description: "GitHub issue #7541: Redo workflow JSON type hardening with dedicated alias design" + +## User Scenarios & Testing *(mandatory)* + +### User Story 1 - Load Existing Workflows Safely (Priority: P1) + +Operators can upgrade Elsa without losing access to persisted workflows whose JSON contains existing type identifiers, including CLR type names emitted by earlier versions. + +**Why this priority**: Backward compatibility is required before hardening can be reintroduced without breaking production workflows. + +**Independent Test**: Load representative persisted workflow JSON that contains legacy type names and verify the workflow can be read while unknown or unsafe type identifiers are rejected. + +**Acceptance Scenarios**: + +1. **Given** a persisted workflow that references a known legacy type name, **When** the workflow is deserialized after upgrade, **Then** the workflow loads successfully. +2. **Given** a persisted workflow that references an unknown or untrusted type name, **When** the workflow is deserialized, **Then** the workflow is rejected with a clear failure instead of resolving arbitrary types. +3. **Given** a persisted workflow that contains abstract, interface, open generic, or collection type identifiers where a concrete workflow type is required, **When** the workflow is deserialized, **Then** the identifier is rejected. + +--- + +### User Story 2 - Use Consistent Type Identifiers in APIs (Priority: P2) + +API consumers receive consistent type identifiers for workflow-facing options such as incident handling strategies and can submit those identifiers back without relying on implementation-specific names. + +**Why this priority**: The reported incident strategy dropdown failure came from inconsistent contracts between API descriptors and hardened workflow JSON reads. + +**Independent Test**: Request descriptor data for incident strategies, select a returned option, and verify a workflow or workflow definition using that option can be accepted and read. + +**Acceptance Scenarios**: + +1. **Given** API descriptor data for incident handling strategies, **When** the options are returned, **Then** every option uses the documented workflow type identifier contract. +2. **Given** a client submits a supported incident strategy identifier from the descriptor payload, **When** the workflow payload is processed, **Then** the identifier resolves to the intended strategy. +3. **Given** older clients submit legacy CLR identifiers during the compatibility window, **When** the workflow payload is processed, **Then** supported legacy identifiers continue to resolve. + +--- + +### User Story 3 - Register Workflow-Serializable Types Explicitly (Priority: P3) + +Module and extension authors can explicitly register the types and legacy names that are valid in workflow serialization payloads without using expression configuration as the trust boundary. + +**Why this priority**: Hardening must be extensible for built-in modules, custom workflow types, runtime payloads, and third-party extensions. + +**Independent Test**: Register a custom workflow-facing type and legacy identifier, then verify alias-based payloads and supported legacy payloads resolve while unrelated types do not. + +**Acceptance Scenarios**: + +1. **Given** a module registers a workflow-serializable type with an alias, **When** workflow JSON references the alias, **Then** the type resolves successfully. +2. **Given** a module registers a supported legacy name for a workflow-serializable type, **When** compatibility JSON references the legacy name, **Then** the type resolves successfully. +3. **Given** a type is registered only for expression use, **When** workflow JSON references it, **Then** workflow JSON resolution does not accept it unless it is also registered for workflow serialization. + +### Edge Cases + +- Legacy JSON references a CLR type moved between assemblies or renamed after earlier persistence. +- Payloads reference unknown, untrusted, abstract, interface, open generic, array, dictionary, or collection types. +- JSON islands contain values that resemble type metadata but should remain normal JSON data. +- Runtime trigger and bookmark payloads include polymorphic values that need the same trust model as workflow definitions. +- Custom workflow types are registered by host applications or extensions after core services are configured. + +## Requirements *(mandatory)* + +### Functional Requirements + +- **FR-001**: The system MUST keep workflow JSON type resolution separate from expression type alias configuration. +- **FR-002**: The system MUST provide a dedicated registry or resolver for workflow-serializable type identifiers. +- **FR-003**: The system MUST allow built-in modules, extensions, and host applications to register workflow-serializable aliases. +- **FR-004**: The system MUST allow supported legacy type names to be registered for backward-compatible reads. +- **FR-005**: The system MUST document which legacy identifiers remain readable during the compatibility window and how unsupported identifiers fail. +- **FR-006**: The system MUST reject unknown, untrusted, abstract, open generic, interface, and inappropriate collection type identifiers when resolving workflow JSON types. +- **FR-007**: The system MUST continue loading existing workflows that reference supported CLR type names during the compatibility window. +- **FR-008**: The system MUST serialize new workflow-facing payloads with the documented type identifier contract where the payload belongs to that contract. +- **FR-009**: The system MUST keep public API payloads that expose workflow type identifiers internally consistent for request and response flows. +- **FR-010**: The system MUST cover the incident handling strategy option flow with a regression test. +- **FR-011**: The system MUST cover persisted workflow JSON, alias JSON, runtime trigger or bookmark payloads, JSON islands, and custom workflow types with tests. +- **FR-012**: The system MUST document the security model, trust boundaries, and migration behavior before hardened resolution is reintroduced. + +### Key Entities *(include if feature involves data)* + +- **Workflow Type Identifier**: A stable value used in workflow-facing JSON or API payloads to identify an allowed type. +- **Workflow-Serializable Type Registration**: A trusted registration that maps a workflow type identifier and optional legacy names to a concrete allowed type. +- **Compatibility Window**: The supported period or mode in which selected legacy CLR type names remain readable. +- **Public Type Identifier Contract**: The documented request and response behavior for API payloads that expose workflow type identifiers. + +## Success Criteria *(mandatory)* + +### Measurable Outcomes + +- **SC-001**: All representative legacy workflow JSON fixtures covered by tests load successfully when they use supported legacy identifiers. +- **SC-002**: Tests demonstrate rejection for unknown, untrusted, abstract, interface, open generic, and inappropriate collection type identifiers. +- **SC-003**: Incident strategy descriptor and submit flows pass a regression test that uses the same identifier contract in both directions. +- **SC-004**: New workflow JSON hardening tests run without depending on expression type alias configuration. +- **SC-005**: Documentation explains the trust model and compatibility behavior clearly enough for module authors to register workflow-serializable types without reading implementation code. + +## Assumptions + +- The compatibility window accepts known Elsa workflow-related CLR type names and explicitly registered host or extension legacy names, not arbitrary CLR resolution. +- Public API type identifier changes can be transitional: aliases are preferred for new payloads while supported legacy values remain readable. +- Existing workflow JSON fixtures are sufficient to represent persisted workflow compatibility risks, with new fixtures added where gaps are found. +- Cloud vault, external migration tooling, and data store schema changes are outside this feature unless existing tests prove they are required. diff --git a/specs/010-workflow-json-hardening/tasks.md b/specs/010-workflow-json-hardening/tasks.md new file mode 100644 index 000000000..00ec64244 --- /dev/null +++ b/specs/010-workflow-json-hardening/tasks.md @@ -0,0 +1,125 @@ +# Tasks: Workflow JSON Type Hardening + +**Input**: Design documents from `/specs/010-workflow-json-hardening/` +**Prerequisites**: plan.md, spec.md, research.md, data-model.md, contracts/ + +**Tests**: Required by the feature specification for compatibility, rejection behavior, incident strategies, runtime payloads, JSON islands, and custom workflow types. + +## Phase 1: Setup (Shared Infrastructure) + +**Purpose**: Confirm the clean worktree and documentation context. + +- [x] T001 Verify the dedicated worktree status in `/Users/sipke/Projects/Elsa/elsa-core-7541` +- [x] T002 Update Spec Kit agent context in `/Users/sipke/Projects/Elsa/elsa-core-7541/AGENTS.md` + +--- + +## Phase 2: Foundational (Blocking Prerequisites) + +**Purpose**: Add the dedicated workflow JSON trust boundary before changing user-facing behavior. + +- [x] T003 Add serialization type registry contracts in `src/modules/Elsa.Common/Serialization/ISerializationTypeRegistry.cs` +- [x] T004 Add serialization type options in `src/modules/Elsa.Common/Serialization/SerializationTypeOptions.cs` +- [x] T005 Add serialization type registry implementation in `src/modules/Elsa.Common/Serialization/SerializationTypeRegistry.cs` +- [x] T006 Add workflow JSON registration extensions in `src/modules/Elsa.Common/Extensions/SerializationTypeOptionsExtensions.cs` +- [x] T007 Update workflow JSON resolver to use the dedicated registry in `src/modules/Elsa.Common/Serialization/SerializationTypeResolver.cs` +- [x] T008 Update workflow type converters to use the dedicated registry in `src/modules/Elsa.Workflows.Core/Serialization/Converters/TypeJsonConverter.cs`, `src/modules/Elsa.Workflows.Core/Serialization/Converters/PolymorphicObjectConverter.cs`, `src/modules/Elsa.Workflows.Core/Serialization/Converters/PolymorphicObjectConverterFactory.cs`, and `src/modules/Elsa.Workflows.Core/Serialization/Converters/PolymorphicDictionaryConverter.cs` + +**Checkpoint**: Workflow JSON converters no longer depend on `ExpressionOptions`. + +--- + +## Phase 3: User Story 1 - Load Existing Workflows Safely (Priority: P1) MVP + +**Goal**: Existing registered CLR type names remain readable while unsafe names fail. + +**Independent Test**: Deserialize legacy workflow JSON/type payloads with registered names and verify unsafe identifiers are rejected. + +### Tests for User Story 1 + +- [x] T009 [US1] Update resolver tests for dedicated registry compatibility in `test/unit/Elsa.Workflows.Core.UnitTests/Serialization/Converters/SerializationTypeResolverTests.cs` +- [x] T010 [US1] Add regression coverage for expression-only aliases not being accepted by workflow JSON in `test/unit/Elsa.Workflows.Core.UnitTests/Serialization/Converters/SerializationTypeResolverTests.cs` + +### Implementation for User Story 1 + +- [x] T011 [US1] Register core workflow JSON aliases and legacy names in `src/modules/Elsa.Workflows.Core/Features/WorkflowsFeature.cs` and `src/modules/Elsa.Workflows.Core/ShellFeatures/WorkflowsFeature.cs` +- [x] T012 [US1] Update workflow serializers and hashing to consume `ISerializationTypeRegistry` in `src/modules/Elsa.Workflows.Core/Serialization/Serializers/JsonWorkflowStateSerializer.cs`, `src/modules/Elsa.Workflows.Core/Serialization/Serializers/SafeSerializer.cs`, `src/modules/Elsa.Workflows.Core/Serialization/Serializers/BookmarkPayloadSerializer.cs`, and `src/modules/Elsa.Workflows.Core/Services/Hasher.cs` + +**Checkpoint**: User Story 1 can be validated independently. + +--- + +## Phase 4: User Story 2 - Use Consistent Type Identifiers in APIs (Priority: P2) + +**Goal**: Incident strategy descriptors emit the same workflow type identifiers that workflow JSON accepts. + +**Independent Test**: Descriptor output for incident strategies returns aliases and supported legacy identifiers remain readable. + +### Tests for User Story 2 + +- [x] T013 [US2] Add incident strategy descriptor regression tests in `test/unit/Elsa.Workflows.Api.UnitTests/Endpoints/IncidentStrategies/ListTests.cs` + +### Implementation for User Story 2 + +- [x] T014 [US2] Register incident strategy aliases and legacy names in `src/modules/Elsa.Workflows.Core/Features/WorkflowsFeature.cs` and `src/modules/Elsa.Workflows.Core/ShellFeatures/WorkflowsFeature.cs` +- [x] T015 [US2] Emit workflow JSON aliases from incident strategy descriptors in `src/modules/Elsa.Workflows.Api/Endpoints/IncidentStrategies/List/Endpoint.cs` +- [x] T016 [US2] Update client model documentation for identifier semantics in `src/clients/Elsa.Api.Client/Resources/IncidentStrategies/Models/IncidentStrategyDescriptor.cs` + +**Checkpoint**: User Story 2 can be validated independently. + +--- + +## Phase 5: User Story 3 - Register Workflow-Serializable Types Explicitly (Priority: P3) + +**Goal**: Modules and host applications register workflow JSON types without using expression options. + +**Independent Test**: Runtime and extension payloads resolve from workflow JSON registrations while expression-only aliases do not. + +### Tests for User Story 3 + +- [x] T017 [US3] Update runtime feature tests for workflow JSON registrations in `test/unit/Elsa.Workflows.Runtime.UnitTests/Features/WorkflowRuntimeFeatureTests.cs` +- [x] T018 [US3] Update runtime trigger comparer tests for the dedicated registry in `test/unit/Elsa.Workflows.Runtime.UnitTests/Comparers/WorkflowTriggerEqualityComparerTests.cs` + +### Implementation for User Story 3 + +- [x] T019 [US3] Move runtime workflow payload registration to workflow JSON options in `src/modules/Elsa.Workflows.Runtime/WorkflowRuntimeTypeAliasRegistrar.cs`, `src/modules/Elsa.Workflows.Runtime/Features/WorkflowRuntimeFeature.cs`, and `src/modules/Elsa.Workflows.Runtime/ShellFeatures/WorkflowRuntimeFeature.cs` +- [x] T020 [US3] Move module payload registrations to workflow JSON options in `src/modules/Elsa.Http/Features/HttpFeature.cs`, `src/modules/Elsa.Http/ShellFeatures/HttpFeature.cs`, `src/modules/Elsa.Scheduling/Features/SchedulingFeature.cs`, `src/modules/Elsa.Resilience/Features/ResilienceFeature.cs`, `src/modules/Elsa.Resilience/ShellFeatures/ResilienceFeature.cs`, `src/modules/Elsa.Alterations/Features/AlterationsFeature.cs`, `src/modules/Elsa.Persistence.EFCore/Modules/Management/WorkflowDefinitionPersistenceFeature.cs`, and `src/modules/Elsa.Workflows.Management/Features/WorkflowManagementFeature.cs` +- [x] T021 [US3] Update runtime trigger comparison to use `ISerializationTypeRegistry` in `src/modules/Elsa.Workflows.Runtime/Comparers/WorkflowTriggerEqualityComparer.cs` and `src/modules/Elsa.Workflows.Runtime/Services/TriggerIndexer.cs` + +**Checkpoint**: User Story 3 can be validated independently. + +--- + +## Phase 6: Polish & Cross-Cutting Concerns + +**Purpose**: Documentation and validation. + +- [x] T022 Add workflow JSON hardening documentation in `doc/wiki/workflow-core.md` +- [x] T023 Run targeted workflow core unit tests with `dotnet test test/unit/Elsa.Workflows.Core.UnitTests/Elsa.Workflows.Core.UnitTests.csproj --filter SerializationTypeResolverTests` +- [x] T024 Run targeted workflow runtime unit tests with `dotnet test test/unit/Elsa.Workflows.Runtime.UnitTests/Elsa.Workflows.Runtime.UnitTests.csproj --filter WorkflowRuntimeFeatureTests` +- [x] T025 Review changed files and ensure `.specify/feature.json` and Spec Kit artifacts are correct + +--- + +## Dependencies & Execution Order + +- **Setup**: T001-T002 first. +- **Foundational**: T003-T008 block all user stories. +- **US1**: T009-T012 produces the MVP compatibility slice. +- **US2**: T013-T016 depends on the registry from Foundational and may run after US1. +- **US3**: T017-T021 depends on the registry from Foundational and may run after US1. +- **Polish**: T022-T025 after implementation. + +## Parallel Opportunities + +- Test updates in T009, T013, T017, and T018 can be developed in parallel after T003-T008. +- Module registration moves in T020 can be parallelized by module after the extension API exists. +- Documentation T022 can run after the contract behavior is finalized. + +## Implementation Strategy + +1. Establish the dedicated registry and switch converters. +2. Preserve legacy compatibility for existing workflow JSON. +3. Align incident strategy API descriptors with the registry. +4. Move runtime/module payload registrations off expression options. +5. Validate with targeted tests and documentation. diff --git a/src/apps/Elsa.ModularServer.Web/Program.cs b/src/apps/Elsa.ModularServer.Web/Program.cs index 3a5624e39..f27fae972 100644 --- a/src/apps/Elsa.ModularServer.Web/Program.cs +++ b/src/apps/Elsa.ModularServer.Web/Program.cs @@ -48,7 +48,6 @@ services.AddOpenTelemetry() .AddHttpClientInstrumentation() .AddMeter(WorkflowInstrumentation.MeterName) .AddOtlpExporter(options => ConfigureDiagnosticsOtlpExporter(options, configuration, "metrics"))); - var nuplaneConfiguration = configuration.GetSection("Nuplane"); services.AddNuplane(nuplaneConfiguration, nuplane => diff --git a/src/clients/Elsa.Api.Client/Resources/IncidentStrategies/Models/IncidentStrategyDescriptor.cs b/src/clients/Elsa.Api.Client/Resources/IncidentStrategies/Models/IncidentStrategyDescriptor.cs index fc401f354..657396a88 100644 --- a/src/clients/Elsa.Api.Client/Resources/IncidentStrategies/Models/IncidentStrategyDescriptor.cs +++ b/src/clients/Elsa.Api.Client/Resources/IncidentStrategies/Models/IncidentStrategyDescriptor.cs @@ -3,7 +3,7 @@ namespace Elsa.Api.Client.Resources.IncidentStrategies.Models; /// /// Represents an incident strategy. /// -/// The .NET type name of the strategy. +/// The workflow JSON type identifier of the strategy. /// The display name of the strategy. /// The description of the strategy. -public record IncidentStrategyDescriptor(string TypeName, string DisplayName, string? Description); \ No newline at end of file +public record IncidentStrategyDescriptor(string TypeName, string DisplayName, string? Description); diff --git a/src/modules/Elsa.Alterations/Features/AlterationsFeature.cs b/src/modules/Elsa.Alterations/Features/AlterationsFeature.cs index 2b608d392..6f9173636 100644 --- a/src/modules/Elsa.Alterations/Features/AlterationsFeature.cs +++ b/src/modules/Elsa.Alterations/Features/AlterationsFeature.cs @@ -6,11 +6,12 @@ using Elsa.Alterations.Core.Stores; using Elsa.Alterations.Extensions; using Elsa.Alterations.Services; using Elsa.Alterations.Workflows; -using Elsa.Workflows.Serialization.Options; using Elsa.Extensions; using Elsa.Features.Abstractions; using Elsa.Features.Services; +using Elsa.Workflows.Options; using Microsoft.Extensions.DependencyInjection; +using Elsa.Common.Serialization; namespace Elsa.Alterations.Features; @@ -60,10 +61,10 @@ public class AlterationsFeature : FeatureBase /// public override void Apply() { - Services.Configure(options => + Services.Configure(options => { - options.RegisterTypeAlias(typeof(AlterationPlanParams), typeof(AlterationPlanParams).GetSimpleAssemblyQualifiedName()); options.RegisterTypeAlias(typeof(AlterationPlanParams), nameof(AlterationPlanParams)); + options.RegisterLegacySimpleAssemblyQualifiedName(typeof(AlterationPlanParams)); }); Services.AddScoped(); diff --git a/src/modules/Elsa.Alterations/ShellFeatures/AlterationsFeature.cs b/src/modules/Elsa.Alterations/ShellFeatures/AlterationsFeature.cs index aa6962a91..8721c3a9c 100644 --- a/src/modules/Elsa.Alterations/ShellFeatures/AlterationsFeature.cs +++ b/src/modules/Elsa.Alterations/ShellFeatures/AlterationsFeature.cs @@ -8,10 +8,11 @@ using Elsa.Alterations.Core.Stores; using Elsa.Alterations.Extensions; using Elsa.Alterations.Services; using Elsa.Alterations.Workflows; -using Elsa.Workflows.Serialization.Options; using Elsa.Extensions; +using Elsa.Workflows.Options; using JetBrains.Annotations; using Microsoft.Extensions.DependencyInjection; +using Elsa.Common.Serialization; namespace Elsa.Alterations.ShellFeatures; @@ -42,10 +43,10 @@ public class AlterationsFeature : IFastEndpointsShellFeature public void ConfigureServices(IServiceCollection services) { - services.Configure(options => + services.Configure(options => { - options.RegisterTypeAlias(typeof(AlterationPlanParams), typeof(AlterationPlanParams).GetSimpleAssemblyQualifiedName()); options.RegisterTypeAlias(typeof(AlterationPlanParams), nameof(AlterationPlanParams)); + options.RegisterLegacySimpleAssemblyQualifiedName(typeof(AlterationPlanParams)); }); services.AddScoped(); diff --git a/src/modules/Elsa.Common/Extensions/SerializationTypeOptionsExtensions.cs b/src/modules/Elsa.Common/Extensions/SerializationTypeOptionsExtensions.cs new file mode 100644 index 000000000..fe257dbe3 --- /dev/null +++ b/src/modules/Elsa.Common/Extensions/SerializationTypeOptionsExtensions.cs @@ -0,0 +1,53 @@ +using Elsa.Common.Serialization; + +// ReSharper disable once CheckNamespace +namespace Elsa.Extensions; + +/// +/// Extends . +/// +public static class SerializationTypeOptionsExtensions +{ + /// + /// Registers a preferred serialization alias. + /// + public static SerializationTypeOptions AddTypeAlias(this SerializationTypeOptions options, string alias) => options.RegisterTypeAlias(typeof(T), alias); + + /// + /// Registers the type name as the preferred serialization alias. + /// + public static SerializationTypeOptions AddTypeAlias(this SerializationTypeOptions options) => options.RegisterTypeAlias(typeof(T), typeof(T).Name); + + /// + /// Registers a preferred serialization alias and the current simple assembly-qualified name as a legacy identifier. + /// + public static SerializationTypeOptions AddTypeAliasWithLegacyName(this SerializationTypeOptions options, Type type, string alias) + { + options.RegisterTypeAlias(type, alias); + options.RegisterLegacySimpleAssemblyQualifiedName(type); + return options; + } + + /// + /// Registers a preferred serialization alias and the current simple assembly-qualified name as a legacy identifier. + /// + public static SerializationTypeOptions AddTypeAliasWithLegacyName(this SerializationTypeOptions options, string alias) => options.AddTypeAliasWithLegacyName(typeof(T), alias); + + /// + /// Registers the current simple assembly-qualified name as a compatibility identifier. + /// + public static SerializationTypeOptions AddLegacySimpleAssemblyQualifiedName(this SerializationTypeOptions options) => options.RegisterLegacySimpleAssemblyQualifiedName(typeof(T)); + + /// + /// Registers the current simple assembly-qualified name as a compatibility identifier. + /// + public static SerializationTypeOptions AddLegacySimpleAssemblyQualifiedName(this SerializationTypeOptions options, Type type) => options.RegisterLegacySimpleAssemblyQualifiedName(type); + + /// + /// Registers the current simple assembly-qualified name as the preferred alias for compatibility-only types. + /// + public static SerializationTypeOptions AddSimpleAssemblyQualifiedTypeAlias(this SerializationTypeOptions options, Type type) + { + return options.RegisterTypeAlias(type, type.GetSimpleAssemblyQualifiedName()); + } +} diff --git a/src/modules/Elsa.Common/Extensions/TypeExtensions.cs b/src/modules/Elsa.Common/Extensions/TypeExtensions.cs index 863a2057b..588eda811 100644 --- a/src/modules/Elsa.Common/Extensions/TypeExtensions.cs +++ b/src/modules/Elsa.Common/Extensions/TypeExtensions.cs @@ -1,3 +1,5 @@ +using System.Collections.Concurrent; + // ReSharper disable once CheckNamespace namespace Elsa.Extensions; @@ -6,6 +8,17 @@ namespace Elsa.Extensions; /// public static class TypeExtensions { + private static readonly ConcurrentDictionary SimpleAssemblyQualifiedTypeNameCache = new(); + + /// + /// Gets the assembly-qualified name of the type, without version, culture, and public key token information. + /// + public static string GetSimpleAssemblyQualifiedName(this Type type) + { + if (type is null) throw new ArgumentNullException(nameof(type)); + return SimpleAssemblyQualifiedTypeNameCache.GetOrAdd(type, BuildSimplifiedName); + } + /// /// Returns true of the type is generic, false otherwise. /// @@ -54,4 +67,22 @@ public static class TypeExtensions { return type.IsPrimitive || type == typeof(decimal) || type == typeof(float) || type == typeof(double) || type == typeof(int) || type == typeof(long) || type == typeof(short) || type == typeof(byte) || type == typeof(uint) || type == typeof(ulong) || type == typeof(ushort) || type == typeof(sbyte); } -} \ No newline at end of file + + private static string BuildSimplifiedName(Type type) + { + var assemblyName = type.Assembly.GetName().Name; + + if (type.IsGenericType) + { + var genericTypeName = type.GetGenericTypeDefinition().FullName!; + var backtickIndex = genericTypeName.IndexOf('`'); + var typeNameWithoutArity = genericTypeName[..backtickIndex]; + var arity = genericTypeName[backtickIndex..]; + var simplifiedGenericArguments = type.GetGenericArguments().Select(BuildSimplifiedName); + + return $"{typeNameWithoutArity}{arity}[[{string.Join("],[", simplifiedGenericArguments)}]], {assemblyName}"; + } + + return $"{type.FullName}, {assemblyName}"; + } +} diff --git a/src/modules/Elsa.Common/Serialization/ISerializationTypeRegistry.cs b/src/modules/Elsa.Common/Serialization/ISerializationTypeRegistry.cs new file mode 100644 index 000000000..123963a1f --- /dev/null +++ b/src/modules/Elsa.Common/Serialization/ISerializationTypeRegistry.cs @@ -0,0 +1,27 @@ +namespace Elsa.Common.Serialization; + +/// +/// A registry of types that may be resolved from serialization type identifiers. +/// +public interface ISerializationTypeRegistry +{ + /// + /// Registers a type with an alias. + /// + void RegisterType(Type type, string alias); + + /// + /// Attempts to get the preferred alias for the specified type. + /// + bool TryGetAlias(Type type, out string alias); + + /// + /// Attempts to get the type associated with the specified alias or legacy name. + /// + bool TryGetType(string alias, out Type type); + + /// + /// Returns all registered types. + /// + IEnumerable ListTypes(); +} diff --git a/src/modules/Elsa.Common/Serialization/SerializationTypeOptions.cs b/src/modules/Elsa.Common/Serialization/SerializationTypeOptions.cs new file mode 100644 index 000000000..d252fd068 --- /dev/null +++ b/src/modules/Elsa.Common/Serialization/SerializationTypeOptions.cs @@ -0,0 +1,85 @@ +using System.Collections.ObjectModel; +using System.Dynamic; +using System.Text.Json; +using System.Text.Json.Nodes; +using Elsa.Extensions; + +namespace Elsa.Common.Serialization; + +/// +/// Options for serialization type identifiers. +/// +public class SerializationTypeOptions +{ + private readonly IDictionary _aliasTypeDictionary = new Dictionary(StringComparer.OrdinalIgnoreCase); + private readonly IDictionary _typeAliasDictionary = new Dictionary(); + + /// + /// Initializes a new instance of the class. + /// + public SerializationTypeOptions() + { + AliasTypeDictionary = new ReadOnlyDictionary(_aliasTypeDictionary); + TypeAliasDictionary = new ReadOnlyDictionary(_typeAliasDictionary); + + RegisterTypeAlias(typeof(short), "Int16"); + RegisterTypeAlias(typeof(int), "Int32"); + RegisterTypeAlias(typeof(long), "Int64"); + RegisterLegacyTypeName(typeof(long), "Long"); + RegisterTypeAlias(typeof(float), "Single"); + RegisterTypeAlias(typeof(object), "Object"); + RegisterTypeAlias(typeof(string), "String"); + RegisterTypeAlias(typeof(bool), "Boolean"); + RegisterTypeAlias(typeof(decimal), "Decimal"); + RegisterTypeAlias(typeof(double), "Double"); + RegisterTypeAlias(typeof(byte[]), "ByteArray"); + RegisterTypeAlias(typeof(Guid), nameof(Guid)); + RegisterTypeAlias(typeof(DateTime), nameof(DateTime)); + RegisterTypeAlias(typeof(DateTimeOffset), nameof(DateTimeOffset)); + RegisterTypeAlias(typeof(TimeSpan), nameof(TimeSpan)); + RegisterTypeAlias(typeof(Stream), nameof(Stream)); + RegisterTypeAlias(typeof(ExpandoObject), "JSON"); + RegisterTypeAlias(typeof(JsonElement), nameof(JsonElement)); + RegisterTypeAlias(typeof(JsonNode), nameof(JsonNode)); + RegisterTypeAlias(typeof(JsonObject), nameof(JsonObject)); + RegisterTypeAlias(typeof(JsonArray), nameof(JsonArray)); + RegisterTypeAlias(typeof(IDictionary), "StringDictionary"); + RegisterTypeAlias(typeof(IDictionary), "ObjectDictionary"); + RegisterTypeAlias(typeof(Dictionary), "StringMap"); + RegisterTypeAlias(typeof(Dictionary), "ObjectMap"); + } + + /// + /// Gets aliases and legacy names keyed by identifier. + /// + public IDictionary AliasTypeDictionary { get; } + + /// + /// Gets preferred aliases keyed by type. + /// + public IDictionary TypeAliasDictionary { get; } + + /// + /// Registers a preferred serialization alias. + /// + public SerializationTypeOptions RegisterTypeAlias(Type type, string alias) + { + _aliasTypeDictionary[alias] = type; + _typeAliasDictionary[type] = alias; + return this; + } + + /// + /// Registers a legacy serialization identifier for compatibility reads. + /// + public SerializationTypeOptions RegisterLegacyTypeName(Type type, string typeName) + { + _aliasTypeDictionary[typeName] = type; + return this; + } + + /// + /// Registers the type's simple assembly-qualified name as a legacy serialization identifier. + /// + public SerializationTypeOptions RegisterLegacySimpleAssemblyQualifiedName(Type type) => RegisterLegacyTypeName(type, type.GetSimpleAssemblyQualifiedName()); +} diff --git a/src/modules/Elsa.Common/Serialization/SerializationTypeRegistry.cs b/src/modules/Elsa.Common/Serialization/SerializationTypeRegistry.cs new file mode 100644 index 000000000..9b02f2d61 --- /dev/null +++ b/src/modules/Elsa.Common/Serialization/SerializationTypeRegistry.cs @@ -0,0 +1,60 @@ +using Microsoft.Extensions.Options; + +namespace Elsa.Common.Serialization; + +/// +public class SerializationTypeRegistry : ISerializationTypeRegistry +{ + private readonly Dictionary _aliasTypeDictionary = new(StringComparer.OrdinalIgnoreCase); + private readonly Dictionary _typeAliasDictionary = new(); + + /// + /// Creates a default registry. + /// + public static ISerializationTypeRegistry CreateDefault() + { + return new SerializationTypeRegistry(Microsoft.Extensions.Options.Options.Create(new SerializationTypeOptions())); + } + + /// + /// Initializes a new instance of the class. + /// + public SerializationTypeRegistry(IOptions options) + { + foreach (var entry in options.Value.AliasTypeDictionary) + RegisterTypeName(entry.Value, entry.Key); + + foreach (var entry in options.Value.TypeAliasDictionary) + RegisterType(entry.Key, entry.Value); + } + + /// + public void RegisterType(Type type, string alias) + { + _typeAliasDictionary[type] = alias; + RegisterTypeName(type, alias); + } + + /// + public bool TryGetAlias(Type type, out string alias) => _typeAliasDictionary.TryGetValue(type, out alias!); + + /// + public bool TryGetType(string alias, out Type type) => _aliasTypeDictionary.TryGetValue(alias, out type!); + + /// + public IEnumerable ListTypes() => _aliasTypeDictionary.Values.Distinct(); + + private void RegisterTypeName(Type type, string alias) + { + _aliasTypeDictionary[alias] = type; + + if (type.IsPrimitive || type.IsValueType && Nullable.GetUnderlyingType(type) == null) + { + var nullableType = typeof(Nullable<>).MakeGenericType(type); + _aliasTypeDictionary[$"{alias}?"] = nullableType; + + if (_typeAliasDictionary.ContainsKey(type)) + _typeAliasDictionary[nullableType] = $"{alias}?"; + } + } +} diff --git a/src/modules/Elsa.Workflows.Core/Serialization/Helpers/WorkflowJsonTypeResolver.cs b/src/modules/Elsa.Common/Serialization/SerializationTypeResolver.cs similarity index 60% rename from src/modules/Elsa.Workflows.Core/Serialization/Helpers/WorkflowJsonTypeResolver.cs rename to src/modules/Elsa.Common/Serialization/SerializationTypeResolver.cs index d5258b9ae..250a25326 100644 --- a/src/modules/Elsa.Workflows.Core/Serialization/Helpers/WorkflowJsonTypeResolver.cs +++ b/src/modules/Elsa.Common/Serialization/SerializationTypeResolver.cs @@ -3,14 +3,13 @@ using System.Collections.ObjectModel; using System.Reflection; using System.Text.Json; using Elsa.Extensions; -using Elsa.Workflows.Serialization.Options; -namespace Elsa.Workflows.Serialization.Helpers; +namespace Elsa.Common.Serialization; /// -/// Resolves workflow JSON type aliases and CLR type names. +/// Resolves serialization type aliases without loading arbitrary CLR type names. /// -public static class WorkflowJsonTypeResolver +public static class SerializationTypeResolver { private static readonly IDictionary GenericCollectionTypes = new Dictionary(StringComparer.Ordinal) { @@ -52,47 +51,85 @@ public static class WorkflowJsonTypeResolver [typeof(IDictionary)] = typeof(Dictionary) }; - public static Type ResolveType(WorkflowJsonOptions workflowJsonOptions, string? typeAlias, bool allowLegacyClrTypeNames = true) + /// + /// Resolves the specified serialization type alias. + /// + public static Type ResolveType(ISerializationTypeRegistry serializationTypeRegistry, string? typeAlias) { if (string.IsNullOrWhiteSpace(typeAlias)) - throw new JsonException("The workflow JSON type alias is missing."); + throw new JsonException("The serialization type alias is missing."); - if (TryResolveType(workflowJsonOptions, typeAlias, allowLegacyClrTypeNames, out var type)) + if (TryResolveType(serializationTypeRegistry, typeAlias, out var type)) return type; - var supportedTypeNames = allowLegacyClrTypeNames - ? "Registered aliases, supported compound aliases, and CLR type names" - : "Registered aliases, supported compound aliases, and registered legacy CLR type names"; - throw new JsonException($"Unknown workflow JSON type alias '{typeAlias}'. {supportedTypeNames} can be deserialized."); + throw new JsonException( + $"Unknown serialization type alias '{typeAlias}'. Only registered aliases and supported compound aliases can be deserialized."); } - public static bool TryResolveType(WorkflowJsonOptions workflowJsonOptions, string typeAlias, out Type type) - { - return TryResolveType(workflowJsonOptions, typeAlias, true, out type); - } - - public static bool TryResolveType(WorkflowJsonOptions workflowJsonOptions, string typeAlias, bool allowLegacyClrTypeNames, out Type type) + /// + /// Attempts to resolve the specified serialization type alias. + /// + public static bool TryResolveType(ISerializationTypeRegistry serializationTypeRegistry, string typeAlias, out Type type) { IReadOnlyList? registeredTypes = null; - return TryResolveType(workflowJsonOptions, typeAlias, allowLegacyClrTypeNames, ref registeredTypes, out type); + return TryResolveType(serializationTypeRegistry, typeAlias, ref registeredTypes, out type); } - public static bool TryGetAlias(WorkflowJsonOptions workflowJsonOptions, Type type, out string alias) + private static bool TryResolveType(ISerializationTypeRegistry serializationTypeRegistry, string typeAlias, ref IReadOnlyList? registeredTypes, out Type type) { - if (workflowJsonOptions.TryGetAlias(type, out alias!)) + if (serializationTypeRegistry.TryGetType(typeAlias, out var registeredType)) + { + type = registeredType; + return true; + } + + if (TryResolveArrayType(serializationTypeRegistry, typeAlias, ref registeredTypes, out var arrayType)) + { + type = arrayType; + return true; + } + + if (TryResolveGenericCollectionType(serializationTypeRegistry, typeAlias, ref registeredTypes, out var genericCollectionType)) + { + type = genericCollectionType; + return true; + } + + if (TryResolveRegisteredLegacyTypeName(serializationTypeRegistry, typeAlias, ref registeredTypes, out var legacyType)) + { + type = legacyType; + return true; + } + + type = null!; + return false; + } + + /// + /// Attempts to return a serialization type alias that this resolver can read back. + /// + public static bool TryGetAlias(ISerializationTypeRegistry serializationTypeRegistry, Type type, out string alias) + { + if (serializationTypeRegistry.TryGetAlias(type, out alias!)) return true; - if (type.IsArray && TryGetAlias(workflowJsonOptions, type.GetElementType()!, out var elementTypeAlias)) + if (type.IsArray) { - alias = $"{elementTypeAlias}[]"; - return true; + var elementType = type.GetElementType()!; + + if (TryGetAlias(serializationTypeRegistry, elementType, out var elementTypeAlias)) + { + alias = $"{elementTypeAlias}[]"; + return true; + } } if (type is { IsGenericType: true, GenericTypeArguments.Length: 1 }) { var genericTypeDefinition = type.GetGenericTypeDefinition(); + if (TryGetWritableGenericCollectionAlias(genericTypeDefinition, out var genericTypeAlias) && - TryGetAlias(workflowJsonOptions, type.GenericTypeArguments[0], out elementTypeAlias)) + TryGetAlias(serializationTypeRegistry, type.GenericTypeArguments[0], out var elementTypeAlias)) { alias = $"{genericTypeAlias}<{elementTypeAlias}>"; return true; @@ -103,17 +140,9 @@ public static class WorkflowJsonTypeResolver return false; } - public static string GetAliasOrLegacyClrTypeName(WorkflowJsonOptions workflowJsonOptions, Type type) - { - if (TryGetAlias(workflowJsonOptions, type, out var alias)) - return alias; - - if (!workflowJsonOptions.AllowLegacyClrTypeNames) - throw new JsonException($"Type '{type}' is not registered as a workflow JSON type alias."); - - return type.GetSimpleAssemblyQualifiedName(); - } - + /// + /// Attempts to map a supported collection interface type to an instantiable concrete type. + /// public static bool TryGetInstantiableCollectionType(Type type, out Type instantiableType) { if (type.IsGenericType) @@ -133,41 +162,22 @@ public static class WorkflowJsonTypeResolver return false; } - private static bool TryResolveType(WorkflowJsonOptions workflowJsonOptions, string typeAlias, bool allowLegacyClrTypeNames, ref IReadOnlyList? registeredTypes, out Type type) - { - if (workflowJsonOptions.TryGetType(typeAlias, out type!)) - return true; - - if (TryResolveArrayType(workflowJsonOptions, typeAlias, allowLegacyClrTypeNames, ref registeredTypes, out type)) - return true; - - if (TryResolveGenericCollectionType(workflowJsonOptions, typeAlias, allowLegacyClrTypeNames, ref registeredTypes, out type)) - return true; - - if (TryResolveRegisteredLegacyTypeName(workflowJsonOptions, typeAlias, allowLegacyClrTypeNames, ref registeredTypes, out type)) - return true; - - if (allowLegacyClrTypeNames && TryResolveClrTypeName(typeAlias, out type)) - return true; - - type = null!; - return false; - } - - private static bool TryResolveArrayType(WorkflowJsonOptions workflowJsonOptions, string typeAlias, bool allowLegacyClrTypeNames, ref IReadOnlyList? registeredTypes, out Type type) + private static bool TryResolveArrayType(ISerializationTypeRegistry serializationTypeRegistry, string typeAlias, ref IReadOnlyList? registeredTypes, out Type type) { type = null!; + if (!typeAlias.EndsWith("[]", StringComparison.Ordinal)) return false; - if (!TryResolveType(workflowJsonOptions, typeAlias[..^2], allowLegacyClrTypeNames, ref registeredTypes, out var elementType)) + var elementTypeAlias = typeAlias[..^2]; + if (!TryResolveType(serializationTypeRegistry, elementTypeAlias, ref registeredTypes, out var elementType)) return false; type = elementType.MakeArrayType(); return true; } - private static bool TryResolveGenericCollectionType(WorkflowJsonOptions workflowJsonOptions, string typeAlias, bool allowLegacyClrTypeNames, ref IReadOnlyList? registeredTypes, out Type type) + private static bool TryResolveGenericCollectionType(ISerializationTypeRegistry serializationTypeRegistry, string typeAlias, ref IReadOnlyList? registeredTypes, out Type type) { type = null!; var genericStart = typeAlias.IndexOf('<', StringComparison.Ordinal); @@ -175,10 +185,12 @@ public static class WorkflowJsonTypeResolver if (genericStart <= 0 || !typeAlias.EndsWith(">", StringComparison.Ordinal)) return false; - if (!GenericCollectionTypes.TryGetValue(typeAlias[..genericStart], out var genericTypeDefinition)) + var genericTypeAlias = typeAlias[..genericStart]; + if (!GenericCollectionTypes.TryGetValue(genericTypeAlias, out var genericTypeDefinition)) return false; - if (!TryResolveType(workflowJsonOptions, typeAlias[(genericStart + 1)..^1], allowLegacyClrTypeNames, ref registeredTypes, out var elementType)) + var elementTypeAlias = typeAlias[(genericStart + 1)..^1]; + if (!TryResolveType(serializationTypeRegistry, elementTypeAlias, ref registeredTypes, out var elementType)) return false; type = genericTypeDefinition.MakeGenericType(elementType); @@ -192,60 +204,59 @@ public static class WorkflowJsonTypeResolver if (GenericCollectionInterfaceMappings.TryGetValue(genericTypeDefinition, out var instantiableGenericTypeDefinition) && GenericCollectionAliases.TryGetValue(instantiableGenericTypeDefinition, out alias!)) + { return true; + } alias = null!; return false; } - private static bool TryResolveClrTypeName(string typeAlias, out Type type) + private static bool TryResolveRegisteredLegacyTypeName(ISerializationTypeRegistry serializationTypeRegistry, string typeAlias, ref IReadOnlyList? registeredTypes, out Type type) { - try - { - type = Type.GetType(typeAlias, false)!; - return type != null; - } - catch (Exception e) when (e is ArgumentException or FileLoadException or FileNotFoundException or TypeLoadException or BadImageFormatException) - { - type = null!; - return false; - } - } - - private static bool TryResolveRegisteredLegacyTypeName(WorkflowJsonOptions workflowJsonOptions, string typeAlias, bool allowLegacyClrTypeNames, ref IReadOnlyList? registeredTypes, out Type type) - { - registeredTypes ??= workflowJsonOptions.ListTypes().ToArray(); + registeredTypes ??= GetRegisteredTypes(serializationTypeRegistry); var registeredTypeSnapshot = registeredTypes; - type = registeredTypeSnapshot.FirstOrDefault(x => - string.Equals(x.GetSimpleAssemblyQualifiedName(), typeAlias, StringComparison.Ordinal) || - string.Equals(x.AssemblyQualifiedName, typeAlias, StringComparison.Ordinal))!; - - if (type != null) + if (TryResolveRegisteredSimpleAssemblyQualifiedName(registeredTypeSnapshot, typeAlias, out type)) return true; - if (TryResolveLegacyGenericCollectionTypeName(workflowJsonOptions, typeAlias, allowLegacyClrTypeNames, ref registeredTypes, out type)) + if (TryResolveLegacyGenericCollectionTypeName(serializationTypeRegistry, typeAlias, ref registeredTypes, out type)) return true; + Type? resolvedType; + try { - var resolvedType = Type.GetType( + resolvedType = Type.GetType( typeAlias, assemblyName => ResolveAssembly(registeredTypeSnapshot, assemblyName), (assembly, typeName, ignoreCase) => ResolveType(registeredTypeSnapshot, assembly, typeName, ignoreCase), false); - - type = resolvedType!; - return resolvedType != null; } catch (Exception e) when (e is ArgumentException or FileLoadException) { - type = null!; - return false; + resolvedType = null; } + + type = resolvedType!; + return resolvedType != null; } - private static bool TryResolveLegacyGenericCollectionTypeName(WorkflowJsonOptions workflowJsonOptions, string typeAlias, bool allowLegacyClrTypeNames, ref IReadOnlyList? registeredTypes, out Type type) + private static IReadOnlyList GetRegisteredTypes(ISerializationTypeRegistry serializationTypeRegistry) + { + return serializationTypeRegistry.ListTypes().ToArray(); + } + + private static bool TryResolveRegisteredSimpleAssemblyQualifiedName(IEnumerable registeredTypes, string typeAlias, out Type type) + { + type = registeredTypes.FirstOrDefault(x => + string.Equals(x.GetSimpleAssemblyQualifiedName(), typeAlias, StringComparison.Ordinal) || + string.Equals(x.AssemblyQualifiedName, typeAlias, StringComparison.Ordinal))!; + + return type != null; + } + + private static bool TryResolveLegacyGenericCollectionTypeName(ISerializationTypeRegistry serializationTypeRegistry, string typeAlias, ref IReadOnlyList? registeredTypes, out Type type) { type = null!; @@ -261,9 +272,11 @@ public static class WorkflowJsonTypeResolver if (!string.Equals(assemblyName, genericTypeDefinition.Assembly.GetName().Name, StringComparison.Ordinal)) continue; - if (!TryResolveType(workflowJsonOptions, typeAlias[prefix.Length..separatorIndex], allowLegacyClrTypeNames, ref registeredTypes, out var elementType)) + var elementTypeAlias = typeAlias[prefix.Length..separatorIndex]; + if (!TryResolveType(serializationTypeRegistry, elementTypeAlias, ref registeredTypes, out var elementType)) return false; + // The resolver only closes known collection definitions over registered element types. #pragma warning disable IL2055 type = genericTypeDefinition.MakeGenericType(elementType); #pragma warning restore IL2055 diff --git a/src/modules/Elsa.Diagnostics.ConsoleLogs/Contracts/ElsaConsoleLogFilter.cs b/src/modules/Elsa.Diagnostics.ConsoleLogs/Contracts/ElsaConsoleLogFilter.cs index b4b0e42fb..3579ac646 100644 --- a/src/modules/Elsa.Diagnostics.ConsoleLogs/Contracts/ElsaConsoleLogFilter.cs +++ b/src/modules/Elsa.Diagnostics.ConsoleLogs/Contracts/ElsaConsoleLogFilter.cs @@ -5,21 +5,21 @@ namespace Elsa.Diagnostics.ConsoleLogs.Contracts; /// /// Console log filter accepted by Elsa REST and SignalR endpoints. /// -public sealed class ElsaConsoleLogFilter +public sealed record ElsaConsoleLogFilter { - public string? SourceId { get; set; } + public string? SourceId { get; init; } [JsonConverter(typeof(ConsoleStreamJsonConverter))] - public global::ConsoleLogStreaming.Core.Models.ConsoleStream? Stream { get; set; } - public string? Query { get; set; } - public string? WorkflowInstanceId { get; set; } - public string? WorkflowDefinitionId { get; set; } - public string? WorkflowDefinitionVersionId { get; set; } - public string? ActivityInstanceId { get; set; } - public string? ActivityId { get; set; } - public string? ActivityNodeId { get; set; } - public IDictionary? Metadata { get; set; } - public DateTimeOffset? From { get; set; } - public DateTimeOffset? To { get; set; } - public int? Limit { get; set; } -} + public global::ConsoleLogStreaming.Core.Models.ConsoleStream? Stream { get; init; } + public string? Query { get; init; } + public string? WorkflowInstanceId { get; init; } + public string? WorkflowDefinitionId { get; init; } + public string? WorkflowDefinitionVersionId { get; init; } + public string? ActivityInstanceId { get; init; } + public string? ActivityId { get; init; } + public string? ActivityNodeId { get; init; } + public IReadOnlyDictionary? Metadata { get; init; } + public DateTimeOffset? From { get; init; } + public DateTimeOffset? To { get; init; } + public int? Limit { get; init; } +} \ No newline at end of file diff --git a/src/modules/Elsa.Diagnostics.ConsoleLogs/Endpoints/ConsoleLogs/Sources/Endpoint.cs b/src/modules/Elsa.Diagnostics.ConsoleLogs/Endpoints/ConsoleLogs/Sources/Endpoint.cs index 81858b72b..39246d9b7 100644 --- a/src/modules/Elsa.Diagnostics.ConsoleLogs/Endpoints/ConsoleLogs/Sources/Endpoint.cs +++ b/src/modules/Elsa.Diagnostics.ConsoleLogs/Endpoints/ConsoleLogs/Sources/Endpoint.cs @@ -2,6 +2,7 @@ using ConsoleLogStreaming.Core; using Elsa.Abstractions; using Elsa.Diagnostics.ConsoleLogs.Permissions; using JetBrains.Annotations; +using ConsoleLogSource = ConsoleLogStreaming.Core.Models.ConsoleLogSource; namespace Elsa.Diagnostics.ConsoleLogs.Endpoints.ConsoleLogs.Sources; @@ -16,6 +17,7 @@ internal class Endpoint(IConsoleLogProvider provider) : ElsaEndpointWithoutReque public override async Task> ExecuteAsync(CancellationToken cancellationToken) { - return await provider.ListSourcesAsync(cancellationToken); + var sources = await provider.ListSourcesAsync(cancellationToken); + return sources.ToList(); } } diff --git a/src/modules/Elsa.Expressions.JavaScript/Features/JavaScriptFeature.cs b/src/modules/Elsa.Expressions.JavaScript/Features/JavaScriptFeature.cs index 043008a60..23c0a8281 100644 --- a/src/modules/Elsa.Expressions.JavaScript/Features/JavaScriptFeature.cs +++ b/src/modules/Elsa.Expressions.JavaScript/Features/JavaScriptFeature.cs @@ -1,4 +1,5 @@ using Elsa.Caching.Features; +using Elsa.Expressions.Options; using Elsa.Common.Features; using Elsa.Expressions.Features; using Elsa.Extensions; @@ -15,7 +16,9 @@ using Elsa.Expressions.JavaScript.Services; using Elsa.Expressions.JavaScript.TypeDefinitions.Contracts; using Elsa.Expressions.JavaScript.TypeDefinitions.Services; using Elsa.Workflows; +using Elsa.Workflows.Options; using Microsoft.Extensions.DependencyInjection; +using Elsa.Common.Serialization; namespace Elsa.Expressions.JavaScript.Features; @@ -59,6 +62,8 @@ public class JavaScriptFeature : FeatureBase public override void Apply() { Services.Configure(JintOptions); + Services.Configure(JavaScriptExceptionTypeAliasRegistrar.Register); + Services.Configure(JavaScriptExceptionTypeAliasRegistrar.Register); // JavaScript services. Services @@ -72,7 +77,7 @@ public class JavaScriptFeature : FeatureBase .AddScoped() .AddScoped() .AddScoped() - .AddSingleton() + .AddSingleton() .AddFunctionDefinitionProvider() .AddFunctionDefinitionProvider() .AddFunctionDefinitionProvider() @@ -94,4 +99,4 @@ public class JavaScriptFeature : FeatureBase // UI property handlers. Services.AddScoped(); } -} \ No newline at end of file +} diff --git a/src/modules/Elsa.Expressions.JavaScript/JavaScriptExceptionTypeAliasRegistrar.cs b/src/modules/Elsa.Expressions.JavaScript/JavaScriptExceptionTypeAliasRegistrar.cs new file mode 100644 index 000000000..7ad876ba6 --- /dev/null +++ b/src/modules/Elsa.Expressions.JavaScript/JavaScriptExceptionTypeAliasRegistrar.cs @@ -0,0 +1,34 @@ +using System.Reflection; +using Acornima; +using Elsa.Expressions.Options; +using Elsa.Workflows.Options; +using Jint; +using Jint.Runtime; +using Elsa.Common.Serialization; + +namespace Elsa.Expressions.JavaScript; + +internal static class JavaScriptExceptionTypeAliasRegistrar +{ + public static void Register(ExpressionOptions options) + { + options.RegisterTypeAlias(typeof(ScriptPreparationException), nameof(ScriptPreparationException)); + options.RegisterTypeAlias(typeof(JavaScriptException), nameof(JavaScriptException)); + options.RegisterTypeAlias(typeof(SyntaxErrorException), nameof(SyntaxErrorException)); + + var wrapperExceptionType = typeof(JavaScriptException).GetNestedType("JavaScriptErrorWrapperException", BindingFlags.Public | BindingFlags.NonPublic); + if (wrapperExceptionType != null) + options.RegisterTypeAlias(wrapperExceptionType, "Jint.JavaScriptErrorWrapperException"); + } + + public static void Register(SerializationTypeOptions options) + { + options.RegisterTypeAlias(typeof(ScriptPreparationException), nameof(ScriptPreparationException)); + options.RegisterTypeAlias(typeof(JavaScriptException), nameof(JavaScriptException)); + options.RegisterTypeAlias(typeof(SyntaxErrorException), nameof(SyntaxErrorException)); + + var wrapperExceptionType = typeof(JavaScriptException).GetNestedType("JavaScriptErrorWrapperException", BindingFlags.Public | BindingFlags.NonPublic); + if (wrapperExceptionType != null) + options.RegisterTypeAlias(wrapperExceptionType, "Jint.JavaScriptErrorWrapperException"); + } +} diff --git a/src/modules/Elsa.Expressions.JavaScript/ShellFeatures/JavaScriptFeature.cs b/src/modules/Elsa.Expressions.JavaScript/ShellFeatures/JavaScriptFeature.cs index 8111b335b..27edd192c 100644 --- a/src/modules/Elsa.Expressions.JavaScript/ShellFeatures/JavaScriptFeature.cs +++ b/src/modules/Elsa.Expressions.JavaScript/ShellFeatures/JavaScriptFeature.cs @@ -8,11 +8,14 @@ using Elsa.Expressions.JavaScript.Providers; using Elsa.Expressions.JavaScript.Services; using Elsa.Expressions.JavaScript.TypeDefinitions.Contracts; using Elsa.Expressions.JavaScript.TypeDefinitions.Services; +using Elsa.Expressions.Options; using Elsa.Extensions; using Elsa.PackageManifest.Generator.Hints; using Elsa.Workflows; +using Elsa.Workflows.Options; using JetBrains.Annotations; using Microsoft.Extensions.DependencyInjection; +using Elsa.Common.Serialization; namespace Elsa.Expressions.JavaScript.ShellFeatures; @@ -104,6 +107,8 @@ public class JavaScriptFeature : IShellFeature options.DisableWrappers = DisableWrappers; options.DisableVariableCopying = DisableVariableCopying; }); + services.Configure(JavaScriptExceptionTypeAliasRegistrar.Register); + services.Configure(JavaScriptExceptionTypeAliasRegistrar.Register); // JavaScript services. services @@ -115,7 +120,7 @@ public class JavaScriptFeature : IShellFeature .AddScoped() .AddScoped() .AddScoped() - .AddSingleton() + .AddSingleton() .AddFunctionDefinitionProvider() .AddFunctionDefinitionProvider() .AddFunctionDefinitionProvider() diff --git a/src/modules/Elsa.Expressions/Extensions/TypeExtensions.cs b/src/modules/Elsa.Expressions/Extensions/TypeExtensions.cs index 09b5990a4..b88e4e1ad 100644 --- a/src/modules/Elsa.Expressions/Extensions/TypeExtensions.cs +++ b/src/modules/Elsa.Expressions/Extensions/TypeExtensions.cs @@ -1,4 +1,3 @@ -using System.Collections.Concurrent; using System.Diagnostics.CodeAnalysis; using System.Text; using Elsa.Expressions.Models; @@ -11,18 +10,6 @@ namespace Elsa.Extensions; /// public static class TypeExtensions { - private static readonly ConcurrentDictionary SimpleAssemblyQualifiedTypeNameCache = new(); - - /// - /// Gets the assembly-qualified name of the type, without any version info etc. - /// E.g. "System.String, System.Private.CoreLib" - /// - public static string GetSimpleAssemblyQualifiedName(this Type type) - { - if (type is null) throw new ArgumentNullException(nameof(type)); - return SimpleAssemblyQualifiedTypeNameCache.GetOrAdd(type, GetSimplifiedName); - } - /// /// Returns the default value for the specified type. /// @@ -113,24 +100,4 @@ public static class TypeExtensions return sb.ToString(); } - private static string GetSimplifiedName(Type type) - { - var assemblyName = type.Assembly.GetName().Name; - - if (type.IsGenericType) - { - var genericTypeName = type.GetGenericTypeDefinition().FullName!; - var backtickIndex = genericTypeName.IndexOf('`'); - var typeNameWithoutArity = genericTypeName[..backtickIndex]; - var arity = genericTypeName[backtickIndex..]; - - var genericArguments = type.GetGenericArguments(); - var simplifiedGenericArguments = genericArguments.Select(GetSimplifiedName); - - return $"{typeNameWithoutArity}{arity}[[{string.Join("],[", simplifiedGenericArguments)}]], {assemblyName}"; - } - - var typeName = type.FullName; - return $"{typeName}, {assemblyName}"; - } -} \ No newline at end of file +} diff --git a/src/modules/Elsa.Http/Features/HttpFeature.cs b/src/modules/Elsa.Http/Features/HttpFeature.cs index 6df56020f..6e406665a 100644 --- a/src/modules/Elsa.Http/Features/HttpFeature.cs +++ b/src/modules/Elsa.Http/Features/HttpFeature.cs @@ -1,5 +1,4 @@ using System.Net; -using Elsa.Workflows.Serialization.Options; using Elsa.Extensions; using Elsa.Features.Abstractions; using Elsa.Features.Attributes; @@ -21,12 +20,14 @@ using Elsa.Http.UIHints; using Elsa.Resilience.Extensions; using Elsa.Resilience.Features; using Elsa.Workflows; +using Elsa.Workflows.Options; using FluentStorage; using Microsoft.AspNetCore.Http; using Microsoft.AspNetCore.StaticFiles; using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection.Extensions; using Microsoft.Extensions.Options; +using Elsa.Common.Serialization; namespace Elsa.Http.Features; @@ -247,22 +248,22 @@ public class HttpFeature(IModule module) : FeatureBase(module) foreach (var httpWorkflowInstanceIdSelectorType in HttpWorkflowInstanceIdSelectorTypes) Services.AddScoped(typeof(IHttpWorkflowInstanceIdSelector), httpWorkflowInstanceIdSelectorType); - Services.Configure(options => + Services.Configure(options => { - options.AddTypeAlias("HttpRequest"); - options.AddTypeAlias("HttpResponse"); - options.AddTypeAlias("HttpResponseMessage"); - options.AddTypeAlias("HttpHeaders"); - options.AddTypeAlias("RouteData"); - options.AddTypeAlias("FormFile"); - options.AddTypeAlias("FormFile[]"); - options.AddTypeAlias("HttpFile"); - options.AddTypeAlias("HttpFile[]"); - options.AddTypeAlias("Downloadable"); - options.AddTypeAlias("Downloadable[]"); - options.AddTypeAlias(); - options.AddTypeAlias(); - options.AddTypeAlias(); + options.RegisterTypeAlias(typeof(HttpRequest), "HttpRequest"); + options.RegisterTypeAlias(typeof(HttpResponse), "HttpResponse"); + options.RegisterTypeAlias(typeof(HttpResponseMessage), "HttpResponseMessage"); + options.RegisterTypeAlias(typeof(HttpHeaders), "HttpHeaders"); + options.RegisterTypeAlias(typeof(HttpRouteData), "RouteData"); + options.RegisterTypeAlias(typeof(IFormFile), "FormFile"); + options.RegisterTypeAlias(typeof(IFormFile[]), "FormFile[]"); + options.RegisterTypeAlias(typeof(HttpFile), "HttpFile"); + options.RegisterTypeAlias(typeof(HttpFile[]), "HttpFile[]"); + options.RegisterTypeAlias(typeof(Downloadable), "Downloadable"); + options.RegisterTypeAlias(typeof(Downloadable[]), "Downloadable[]"); + options.RegisterTypeAlias(typeof(HttpStatusCode), nameof(HttpStatusCode)); + options.RegisterTypeAlias(typeof(HttpRequestException), nameof(HttpRequestException)); + options.RegisterTypeAlias(typeof(HttpEndpointBookmarkPayload), nameof(HttpEndpointBookmarkPayload)); }); } } diff --git a/src/modules/Elsa.Http/ShellFeatures/HttpFeature.cs b/src/modules/Elsa.Http/ShellFeatures/HttpFeature.cs index b59c0874b..7f333e191 100644 --- a/src/modules/Elsa.Http/ShellFeatures/HttpFeature.cs +++ b/src/modules/Elsa.Http/ShellFeatures/HttpFeature.cs @@ -1,7 +1,6 @@ using System.Net; using CShells.AspNetCore.Features; using CShells.Features; -using Elsa.Workflows.Serialization.Options; using Elsa.Extensions; using Elsa.Http.Bookmarks; using Elsa.Http.ContentWriters; @@ -20,6 +19,7 @@ using Elsa.Http.UIHints; using Elsa.Resilience.Extensions; using Elsa.Workflows; using Elsa.Workflows.Management.Extensions; +using Elsa.Workflows.Options; using FluentStorage; using JetBrains.Annotations; using Microsoft.AspNetCore.Builder; @@ -28,6 +28,7 @@ using Microsoft.AspNetCore.StaticFiles; using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.Hosting; using Microsoft.Extensions.Options; +using Elsa.Common.Serialization; namespace Elsa.Http.ShellFeatures; @@ -218,22 +219,22 @@ public class HttpFeature : IMiddlewareShellFeature foreach (var httpWorkflowInstanceIdSelectorType in HttpWorkflowInstanceIdSelectorTypes) services.AddScoped(typeof(IHttpWorkflowInstanceIdSelector), httpWorkflowInstanceIdSelectorType); - services.Configure(options => + services.Configure(options => { - options.AddTypeAlias("HttpRequest"); - options.AddTypeAlias("HttpResponse"); - options.AddTypeAlias("HttpResponseMessage"); - options.AddTypeAlias("HttpHeaders"); - options.AddTypeAlias("RouteData"); - options.AddTypeAlias("FormFile"); - options.AddTypeAlias("FormFile[]"); - options.AddTypeAlias("HttpFile"); - options.AddTypeAlias("HttpFile[]"); - options.AddTypeAlias("Downloadable"); - options.AddTypeAlias("Downloadable[]"); - options.AddTypeAlias(); - options.AddTypeAlias(); - options.AddTypeAlias(); + options.RegisterTypeAlias(typeof(HttpRequest), "HttpRequest"); + options.RegisterTypeAlias(typeof(HttpResponse), "HttpResponse"); + options.RegisterTypeAlias(typeof(HttpResponseMessage), "HttpResponseMessage"); + options.RegisterTypeAlias(typeof(HttpHeaders), "HttpHeaders"); + options.RegisterTypeAlias(typeof(HttpRouteData), "RouteData"); + options.RegisterTypeAlias(typeof(IFormFile), "FormFile"); + options.RegisterTypeAlias(typeof(IFormFile[]), "FormFile[]"); + options.RegisterTypeAlias(typeof(HttpFile), "HttpFile"); + options.RegisterTypeAlias(typeof(HttpFile[]), "HttpFile[]"); + options.RegisterTypeAlias(typeof(Downloadable), "Downloadable"); + options.RegisterTypeAlias(typeof(Downloadable[]), "Downloadable[]"); + options.RegisterTypeAlias(typeof(HttpStatusCode), nameof(HttpStatusCode)); + options.RegisterTypeAlias(typeof(HttpRequestException), nameof(HttpRequestException)); + options.RegisterTypeAlias(typeof(HttpEndpointBookmarkPayload), nameof(HttpEndpointBookmarkPayload)); }); } diff --git a/src/modules/Elsa.Persistence.EFCore/Modules/Management/WorkflowDefinitionPersistenceFeature.cs b/src/modules/Elsa.Persistence.EFCore/Modules/Management/WorkflowDefinitionPersistenceFeature.cs index 0c8e27392..b13b41a41 100644 --- a/src/modules/Elsa.Persistence.EFCore/Modules/Management/WorkflowDefinitionPersistenceFeature.cs +++ b/src/modules/Elsa.Persistence.EFCore/Modules/Management/WorkflowDefinitionPersistenceFeature.cs @@ -1,7 +1,9 @@ +using Elsa.Expressions.Options; using Elsa.Features.Attributes; using Elsa.Features.Services; using Elsa.Workflows.Management.Entities; using Elsa.Workflows.Management.Features; +using Elsa.Workflows.Options; using Microsoft.Extensions.DependencyInjection; namespace Elsa.Persistence.EFCore.Modules.Management; @@ -28,4 +30,4 @@ public class EFCoreWorkflowDefinitionPersistenceFeature(IModule module) : Persis base.Apply(); AddEntityStore(); } -} \ No newline at end of file +} diff --git a/src/modules/Elsa.Resilience/Features/ResilienceFeature.cs b/src/modules/Elsa.Resilience/Features/ResilienceFeature.cs index 5cc8f6d3e..887ff7de5 100644 --- a/src/modules/Elsa.Resilience/Features/ResilienceFeature.cs +++ b/src/modules/Elsa.Resilience/Features/ResilienceFeature.cs @@ -10,8 +10,10 @@ using Elsa.Resilience.Recorders; using Elsa.Resilience.Serialization; using Elsa.Resilience.StrategySources; using Elsa.Workflows; +using Elsa.Workflows.Options; using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection.Extensions; +using Elsa.Common.Serialization; namespace Elsa.Resilience.Features; @@ -66,6 +68,11 @@ public class ResilienceFeature(IModule module) : FeatureBase(module) { options.AddTypeAlias>("RetryAttemptRecordList"); }); + + Services.Configure(options => + { + options.RegisterTypeAlias(typeof(List), "RetryAttemptRecordList"); + }); } public override void Apply() diff --git a/src/modules/Elsa.Resilience/ShellFeatures/ResilienceFeature.cs b/src/modules/Elsa.Resilience/ShellFeatures/ResilienceFeature.cs index 4e57ce778..dedacd3c5 100644 --- a/src/modules/Elsa.Resilience/ShellFeatures/ResilienceFeature.cs +++ b/src/modules/Elsa.Resilience/ShellFeatures/ResilienceFeature.cs @@ -10,8 +10,10 @@ using Elsa.Resilience.Recorders; using Elsa.Resilience.Serialization; using Elsa.Resilience.StrategySources; using Elsa.Workflows; +using Elsa.Workflows.Options; using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection.Extensions; +using Elsa.Common.Serialization; namespace Elsa.Resilience.ShellFeatures; @@ -26,6 +28,11 @@ public class ResilienceFeature : IFastEndpointsShellFeature { options.AddTypeAlias>("RetryAttemptRecordList"); }); + + services.Configure(options => + { + options.RegisterTypeAlias(typeof(List), "RetryAttemptRecordList"); + }); services.AddOptions(); services.AddOptions(); diff --git a/src/modules/Elsa.Scheduling/Features/SchedulingFeature.cs b/src/modules/Elsa.Scheduling/Features/SchedulingFeature.cs index df06db78e..20efd0a61 100644 --- a/src/modules/Elsa.Scheduling/Features/SchedulingFeature.cs +++ b/src/modules/Elsa.Scheduling/Features/SchedulingFeature.cs @@ -1,6 +1,5 @@ using Elsa.Common.Features; using Elsa.Common.Multitenancy; -using Elsa.Workflows.Serialization.Options; using Elsa.Extensions; using Elsa.Features.Abstractions; using Elsa.Features.Attributes; @@ -11,7 +10,9 @@ using Elsa.Scheduling.Services; using Elsa.Scheduling.StartupTasks; using Elsa.Scheduling.TriggerPayloadValidators; using Elsa.Workflows.Management.Features; +using Elsa.Workflows.Options; using Microsoft.Extensions.DependencyInjection; +using Elsa.Common.Serialization; namespace Elsa.Scheduling.Features; @@ -58,14 +59,14 @@ public class SchedulingFeature : FeatureBase // Graceful shutdown: register scheduled-trigger ingress for diagnostic visibility (FR-006). .AddSingleton(); - Services.Configure(options => + Services.Configure(options => { - options.AddTypeAlias(); - options.AddTypeAlias(); - options.AddTypeAlias(); - options.AddTypeAlias(); - options.AddTypeAlias(); - options.AddTypeAlias(); + options.RegisterTypeAlias(typeof(CronBookmarkPayload), nameof(CronBookmarkPayload)); + options.RegisterTypeAlias(typeof(CronTriggerPayload), nameof(CronTriggerPayload)); + options.RegisterTypeAlias(typeof(DelayPayload), nameof(DelayPayload)); + options.RegisterTypeAlias(typeof(StartAtPayload), nameof(StartAtPayload)); + options.RegisterTypeAlias(typeof(TimerBookmarkPayload), nameof(TimerBookmarkPayload)); + options.RegisterTypeAlias(typeof(TimerTriggerPayload), nameof(TimerTriggerPayload)); }); Module.Configure(management => management.AddActivitiesFrom()); diff --git a/src/modules/Elsa.Scheduling/ShellFeatures/SchedulingFeature.cs b/src/modules/Elsa.Scheduling/ShellFeatures/SchedulingFeature.cs index 1459795d7..79eb86831 100644 --- a/src/modules/Elsa.Scheduling/ShellFeatures/SchedulingFeature.cs +++ b/src/modules/Elsa.Scheduling/ShellFeatures/SchedulingFeature.cs @@ -1,8 +1,8 @@ using CShells.Features; using Elsa.Common.Multitenancy; using Elsa.Common.ShellFeatures; -using Elsa.Workflows.Serialization.Options; using Elsa.Extensions; +using Elsa.Workflows.Options; using Elsa.Scheduling.Bookmarks; using Elsa.Scheduling.Handlers; using Elsa.Scheduling.Services; @@ -11,6 +11,7 @@ using Elsa.Scheduling.TriggerPayloadValidators; using Elsa.Workflows.Management.Extensions; using JetBrains.Annotations; using Microsoft.Extensions.DependencyInjection; +using Elsa.Common.Serialization; namespace Elsa.Scheduling.ShellFeatures; @@ -51,7 +52,7 @@ public class SchedulingFeature : IShellFeature .AddTriggerPayloadValidator() .AddActivitiesFrom(); - services.Configure(options => + services.Configure(options => { options.AddTypeAlias(); options.AddTypeAlias(); diff --git a/src/modules/Elsa.Workflows.Api/AssemblyInfo.cs b/src/modules/Elsa.Workflows.Api/AssemblyInfo.cs index 2c63c1354..e6bd2a3d1 100644 --- a/src/modules/Elsa.Workflows.Api/AssemblyInfo.cs +++ b/src/modules/Elsa.Workflows.Api/AssemblyInfo.cs @@ -1,3 +1,4 @@ using System.Runtime.CompilerServices; -[assembly: InternalsVisibleTo("Elsa.Workflows.IntegrationTests")] \ No newline at end of file +[assembly: InternalsVisibleTo("Elsa.Workflows.IntegrationTests")] +[assembly: InternalsVisibleTo("Elsa.Workflows.Api.UnitTests")] diff --git a/src/modules/Elsa.Workflows.Api/Endpoints/IncidentStrategies/List/Endpoint.cs b/src/modules/Elsa.Workflows.Api/Endpoints/IncidentStrategies/List/Endpoint.cs index cafa9453d..95c87902b 100644 --- a/src/modules/Elsa.Workflows.Api/Endpoints/IncidentStrategies/List/Endpoint.cs +++ b/src/modules/Elsa.Workflows.Api/Endpoints/IncidentStrategies/List/Endpoint.cs @@ -2,16 +2,17 @@ using System.ComponentModel; using System.ComponentModel.DataAnnotations; using System.Reflection; using Elsa.Abstractions; -using Elsa.Extensions; using Elsa.Models; +using Elsa.Workflows; using Humanizer; +using Elsa.Common.Serialization; namespace Elsa.Workflows.Api.Endpoints.IncidentStrategies.List; /// /// Returns list of available implementations. /// -internal class List(IEnumerable strategies) : ElsaEndpointWithoutRequest> +internal class List(IEnumerable strategies, ISerializationTypeRegistry workflowJsonTypeRegistry) : ElsaEndpointWithoutRequest> { public override void Configure() { @@ -21,15 +22,15 @@ internal class List(IEnumerable strategies) : ElsaEndpointWit public override Task> ExecuteAsync(CancellationToken cancellationToken) { - var descriptors = strategies.Select(IncidentStrategyDescriptor.FromStrategy).OrderBy(x => x.DisplayName).ToList(); - var response =new ListResponse(descriptors); + var descriptors = strategies.Select(x => IncidentStrategyDescriptor.FromStrategy(x, workflowJsonTypeRegistry)).OrderBy(x => x.DisplayName).ToList(); + var response = new ListResponse(descriptors); return Task.FromResult(response); } } internal record IncidentStrategyDescriptor(string DisplayName, string Description, string TypeName) { - public static IncidentStrategyDescriptor FromStrategy(IIncidentStrategy strategy) + public static IncidentStrategyDescriptor FromStrategy(IIncidentStrategy strategy, ISerializationTypeRegistry workflowJsonTypeRegistry) { var type = strategy.GetType(); var displayNameAttribute = type.GetCustomAttribute(); @@ -38,6 +39,7 @@ internal record IncidentStrategyDescriptor(string DisplayName, string Descriptio var displayName = displayNameAttribute?.DisplayName ?? displayAttribute?.Name ?? type.Name.Replace("Strategy", "").Humanize(); var description = descriptionAttribute?.Description ?? displayAttribute?.Description ?? ""; - return new IncidentStrategyDescriptor(displayName, description, type.GetSimpleAssemblyQualifiedName()); + var typeName = workflowJsonTypeRegistry.TryGetAlias(type, out var alias) ? alias : type.FullName!; + return new IncidentStrategyDescriptor(displayName, description, typeName); } -} \ No newline at end of file +} diff --git a/src/modules/Elsa.Workflows.Core/Activities/Flowchart/Serialization/FlowchartJsonConverter.cs b/src/modules/Elsa.Workflows.Core/Activities/Flowchart/Serialization/FlowchartJsonConverter.cs index 71bfbb4a6..afa42aaf6 100644 --- a/src/modules/Elsa.Workflows.Core/Activities/Flowchart/Serialization/FlowchartJsonConverter.cs +++ b/src/modules/Elsa.Workflows.Core/Activities/Flowchart/Serialization/FlowchartJsonConverter.cs @@ -4,10 +4,9 @@ using Elsa.Extensions; using Elsa.Workflows.Activities.Flowchart.Models; using Elsa.Workflows.Memory; using Elsa.Workflows.Serialization.Converters; -using Elsa.Workflows.Serialization.Options; using JetBrains.Annotations; using Microsoft.Extensions.Logging; -using Microsoft.Extensions.Options; +using Elsa.Common.Serialization; namespace Elsa.Workflows.Activities.Flowchart.Serialization; @@ -15,7 +14,7 @@ namespace Elsa.Workflows.Activities.Flowchart.Serialization; /// A JSON converter for . /// [UsedImplicitly] -public class FlowchartJsonConverter(IIdentityGenerator identityGenerator, IOptions workflowJsonOptions, ILoggerFactory loggerFactory) : JsonConverter +public class FlowchartJsonConverter(IIdentityGenerator identityGenerator, ISerializationTypeRegistry workflowJsonTypeRegistry, ILoggerFactory loggerFactory) : JsonConverter { private const string AllActivitiesKey = "allActivities"; private const string AllConnectionsKey = "allConnections"; @@ -48,7 +47,7 @@ public class FlowchartJsonConverter(IIdentityGenerator identityGenerator, IOptio var variables = variablesElement.ValueKind != JsonValueKind.Undefined ? variablesElement.Deserialize>(options) ?? new List() : new List(); var polymorphicOptions = options.Clone(); - polymorphicOptions.Converters.Add(new PolymorphicDictionaryConverter(options, workflowJsonOptions.Value)); + polymorphicOptions.Converters.Add(new PolymorphicDictionaryConverter(options, workflowJsonTypeRegistry)); var metadataElement = doc.RootElement.TryGetProperty("metadata", out var metadataEl) ? metadataEl : default; var metadata = metadataElement.ValueKind != JsonValueKind.Undefined ? metadataElement.Deserialize>(polymorphicOptions) ?? new Dictionary() : new Dictionary(); @@ -106,7 +105,7 @@ public class FlowchartJsonConverter(IIdentityGenerator identityGenerator, IOptio var flowchartSerializerOptions = new JsonSerializerOptions(options); flowchartSerializerOptions.Converters.Add(new ConnectionJsonConverter(activityDictionary, loggerFactory)); - flowchartSerializerOptions.Converters.Add(new PolymorphicDictionaryConverter(options, workflowJsonOptions.Value)); + flowchartSerializerOptions.Converters.Add(new PolymorphicDictionaryConverter(options, workflowJsonTypeRegistry)); JsonSerializer.Serialize(writer, model, flowchartSerializerOptions); } diff --git a/src/modules/Elsa.Workflows.Core/Extensions/WorkflowJsonOptionsExtensions.cs b/src/modules/Elsa.Workflows.Core/Extensions/WorkflowJsonOptionsExtensions.cs deleted file mode 100644 index 851cc8214..000000000 --- a/src/modules/Elsa.Workflows.Core/Extensions/WorkflowJsonOptionsExtensions.cs +++ /dev/null @@ -1,66 +0,0 @@ -using Elsa.Common.Models; -using Elsa.Extensions; -using Elsa.Workflows; -using Elsa.Workflows.Activities.Flowchart.Models; -using Elsa.Workflows.Exceptions; -using Elsa.Workflows.IncidentStrategies; -using Elsa.Workflows.Memory; -using Elsa.Workflows.Models; -using Elsa.Workflows.Serialization.Options; -using Elsa.Workflows.Services; -using Elsa.Workflows.State; -using Newtonsoft.Json.Linq; - -// ReSharper disable once CheckNamespace -namespace Elsa.Extensions; - -/// -/// Extends . -/// -public static class WorkflowJsonOptionsExtensions -{ - /// - /// Registers using its CLR type name. - /// - public static void AddTypeAlias(this WorkflowJsonOptions options) => options.RegisterTypeAlias(typeof(T), typeof(T).Name); - - /// - /// Registers using the specified alias. - /// - public static void AddTypeAlias(this WorkflowJsonOptions options, string alias) => options.RegisterTypeAlias(typeof(T), alias); - - /// - /// Registers the built-in workflow JSON aliases. - /// - public static void RegisterWorkflowTypeAliases(this WorkflowJsonOptions options) - { - options.RegisterTypeAlias(typeof(ExceptionState), nameof(ExceptionState)); - options.RegisterTypeAlias(typeof(FaultException), nameof(FaultException)); - options.RegisterTypeAlias(typeof(VariablesDictionary), nameof(VariablesDictionary)); - options.RegisterTypeAlias(typeof(Token), nameof(Token)); - options.RegisterTypeAlias(typeof(FlowJoinMode), "Elsa.Workflows.Core.Activities.Flowchart.Models.FlowJoinMode, Elsa.Workflows.Core"); - options.RegisterTypeAlias(typeof(FlowJoinMode), typeof(FlowJoinMode).GetSimpleAssemblyQualifiedName()); - options.RegisterTypeAlias(typeof(FlowJoinMode), nameof(FlowJoinMode)); - options.RegisterTypeAlias(typeof(WorkflowStorageDriver), typeof(WorkflowStorageDriver).GetSimpleAssemblyQualifiedName()); - options.RegisterTypeAlias(typeof(WorkflowStorageDriver), nameof(WorkflowStorageDriver)); - options.RegisterTypeAlias(typeof(WorkflowInstanceStorageDriver), typeof(WorkflowInstanceStorageDriver).GetSimpleAssemblyQualifiedName()); - options.RegisterTypeAlias(typeof(WorkflowInstanceStorageDriver), nameof(WorkflowInstanceStorageDriver)); - options.RegisterTypeAlias(typeof(MemoryStorageDriver), typeof(MemoryStorageDriver).GetSimpleAssemblyQualifiedName()); - options.RegisterTypeAlias(typeof(MemoryStorageDriver), nameof(MemoryStorageDriver)); - options.RegisterTypeAlias(typeof(FaultStrategy), typeof(FaultStrategy).GetSimpleAssemblyQualifiedName()); - options.RegisterTypeAlias(typeof(FaultStrategy), nameof(FaultStrategy)); - options.RegisterTypeAlias(typeof(ContinueWithIncidentsStrategy), typeof(ContinueWithIncidentsStrategy).GetSimpleAssemblyQualifiedName()); - options.RegisterTypeAlias(typeof(ContinueWithIncidentsStrategy), nameof(ContinueWithIncidentsStrategy)); - options.RegisterTypeAlias(typeof(Exception), nameof(Exception)); - options.RegisterTypeAlias(typeof(ArgumentException), nameof(ArgumentException)); - options.RegisterTypeAlias(typeof(ArgumentNullException), nameof(ArgumentNullException)); - options.RegisterTypeAlias(typeof(InvalidOperationException), nameof(InvalidOperationException)); - options.RegisterTypeAlias(typeof(NullReferenceException), nameof(NullReferenceException)); - options.RegisterTypeAlias(typeof(OperationCanceledException), nameof(OperationCanceledException)); - options.RegisterTypeAlias(typeof(TaskCanceledException), nameof(TaskCanceledException)); - options.RegisterTypeAlias(typeof(TimeoutException), nameof(TimeoutException)); - options.RegisterTypeAlias(typeof(NotSupportedException), nameof(NotSupportedException)); - options.RegisterTypeAlias(typeof(JObject), nameof(JObject)); - options.RegisterTypeAlias(typeof(JArray), nameof(JArray)); - } -} diff --git a/src/modules/Elsa.Workflows.Core/Features/FlowchartFeature.cs b/src/modules/Elsa.Workflows.Core/Features/FlowchartFeature.cs index 5414125df..8fb59634d 100644 --- a/src/modules/Elsa.Workflows.Core/Features/FlowchartFeature.cs +++ b/src/modules/Elsa.Workflows.Core/Features/FlowchartFeature.cs @@ -4,8 +4,9 @@ using Elsa.Features.Services; using Elsa.Workflows.Activities.Flowchart.Models; using Elsa.Workflows.Activities.Flowchart.Options; using Elsa.Workflows.Activities.Flowchart.Serialization; -using Elsa.Workflows.Serialization.Options; +using Elsa.Workflows.Options; using Microsoft.Extensions.DependencyInjection; +using Elsa.Common.Serialization; namespace Elsa.Workflows.Features; @@ -35,6 +36,6 @@ public class FlowchartFeature : FeatureBase if (FlowchartOptionsConfigurator != null) Services.Configure(FlowchartOptionsConfigurator); - Services.Configure(options => options.AddTypeAlias("FlowScope")); + Services.Configure(options => options.AddTypeAlias("FlowScope")); } } diff --git a/src/modules/Elsa.Workflows.Core/Features/WorkflowsFeature.cs b/src/modules/Elsa.Workflows.Core/Features/WorkflowsFeature.cs index 005b87d09..89c17f04c 100644 --- a/src/modules/Elsa.Workflows.Core/Features/WorkflowsFeature.cs +++ b/src/modules/Elsa.Workflows.Core/Features/WorkflowsFeature.cs @@ -2,19 +2,21 @@ using Elsa.Common; using Elsa.Common.Features; using Elsa.Common.Serialization; using Elsa.Expressions.Features; -using Elsa.Workflows.Serialization.Options; using Elsa.Extensions; using Elsa.Features.Abstractions; using Elsa.Features.Attributes; using Elsa.Features.Services; using Elsa.Workflows.ActivationValidators; +using Elsa.Workflows.Activities.Flowchart.Models; using Elsa.Workflows.Builders; using Elsa.Workflows.CommitStates; +using Elsa.Workflows.Exceptions; using Elsa.Workflows.IncidentStrategies; using Elsa.Workflows.LogPersistence; using Elsa.Workflows.LogPersistence.Strategies; using Elsa.Workflows.Middleware.Activities; using Elsa.Workflows.Middleware.Workflows; +using Elsa.Workflows.Options; using Elsa.Workflows.Pipelines.ActivityExecution; using Elsa.Workflows.Pipelines.WorkflowExecution; using Elsa.Workflows.PortResolvers; @@ -22,12 +24,14 @@ using Elsa.Workflows.Serialization.Configurators; using Elsa.Workflows.Serialization.Helpers; using Elsa.Workflows.Serialization.Serializers; using Elsa.Workflows.Services; +using Elsa.Workflows.State; using Elsa.Workflows.UIHints.CheckList; using Elsa.Workflows.UIHints.Dictionary; using Elsa.Workflows.UIHints.Dropdown; using Elsa.Workflows.UIHints.JsonEditor; using Elsa.Workflows.UIHints.RadioList; using Microsoft.Extensions.DependencyInjection; +using Newtonsoft.Json.Linq; namespace Elsa.Workflows.Features; @@ -165,7 +169,31 @@ public class WorkflowsFeature : FeatureBase private void AddElsaCore(IServiceCollection services) { - services.Configure(options => options.RegisterWorkflowTypeAliases()); + services.Configure(options => + { + options.AddTypeAlias(nameof(ExceptionState)); + options.AddTypeAlias(nameof(FaultException)); + options.AddTypeAlias(nameof(VariablesDictionary)); + options.AddTypeAlias(nameof(Token)); + options.RegisterLegacyTypeName(typeof(FlowJoinMode), "Elsa.Workflows.Core.Activities.Flowchart.Models.FlowJoinMode, Elsa.Workflows.Core"); + options.AddTypeAliasWithLegacyName(nameof(FlowJoinMode)); + options.AddTypeAliasWithLegacyName(nameof(WorkflowStorageDriver)); + options.AddTypeAliasWithLegacyName(nameof(WorkflowInstanceStorageDriver)); + options.AddTypeAliasWithLegacyName(nameof(MemoryStorageDriver)); + options.AddTypeAliasWithLegacyName(nameof(FaultStrategy)); + options.AddTypeAliasWithLegacyName(nameof(ContinueWithIncidentsStrategy)); + options.AddTypeAlias(nameof(Exception)); + options.AddTypeAlias(nameof(ArgumentException)); + options.AddTypeAlias(nameof(ArgumentNullException)); + options.AddTypeAlias(nameof(InvalidOperationException)); + options.AddTypeAlias(nameof(NullReferenceException)); + options.AddTypeAlias(nameof(OperationCanceledException)); + options.AddTypeAlias(nameof(TaskCanceledException)); + options.AddTypeAlias(nameof(TimeoutException)); + options.AddTypeAlias(nameof(NotSupportedException)); + options.AddTypeAlias(nameof(JObject)); + options.AddTypeAlias(nameof(JArray)); + }); services @@ -237,6 +265,7 @@ public class WorkflowsFeature : FeatureBase .AddStorageDriver() // Serialization. + .AddSingleton() .AddSingleton() .AddSingleton() .AddSingleton() diff --git a/src/modules/Elsa.Workflows.Core/Serialization/Converters/OutputJsonConverter.cs b/src/modules/Elsa.Workflows.Core/Serialization/Converters/OutputJsonConverter.cs index 888c732e9..af9f90393 100644 --- a/src/modules/Elsa.Workflows.Core/Serialization/Converters/OutputJsonConverter.cs +++ b/src/modules/Elsa.Workflows.Core/Serialization/Converters/OutputJsonConverter.cs @@ -1,10 +1,9 @@ using System.Text.Json; using System.Text.Json.Serialization; +using Elsa.Extensions; using Elsa.Workflows.Memory; using Elsa.Workflows.Models; -using Elsa.Workflows.Serialization.Helpers; -using Elsa.Workflows.Serialization.Options; -using Microsoft.Extensions.Options; +using Elsa.Common.Serialization; namespace Elsa.Workflows.Serialization.Converters; @@ -13,12 +12,12 @@ namespace Elsa.Workflows.Serialization.Converters; /// public class OutputJsonConverter : JsonConverter?> { - private readonly WorkflowJsonOptions _workflowJsonOptions; + private readonly ISerializationTypeRegistry _workflowJsonTypeRegistry; /// - public OutputJsonConverter(IOptions workflowJsonOptions) + public OutputJsonConverter(ISerializationTypeRegistry workflowJsonTypeRegistry) { - _workflowJsonOptions = workflowJsonOptions.Value; + _workflowJsonTypeRegistry = workflowJsonTypeRegistry; } /// @@ -51,7 +50,9 @@ public class OutputJsonConverter : JsonConverter?> public override void Write(Utf8JsonWriter writer, Output? value, JsonSerializerOptions options) { var valueType = typeof(T); - var valueTypeAlias = WorkflowJsonTypeResolver.GetAliasOrLegacyClrTypeName(_workflowJsonOptions, valueType); + var valueTypeAlias = SerializationTypeResolver.TryGetAlias(_workflowJsonTypeRegistry, valueType, out var alias) + ? alias + : valueType.GetSimpleAssemblyQualifiedName(); var model = new { diff --git a/src/modules/Elsa.Workflows.Core/Serialization/Converters/PolymorphicDictionaryConverter.cs b/src/modules/Elsa.Workflows.Core/Serialization/Converters/PolymorphicDictionaryConverter.cs index 12653413a..347392765 100644 --- a/src/modules/Elsa.Workflows.Core/Serialization/Converters/PolymorphicDictionaryConverter.cs +++ b/src/modules/Elsa.Workflows.Core/Serialization/Converters/PolymorphicDictionaryConverter.cs @@ -1,6 +1,6 @@ using System.Text.Json; using System.Text.Json.Serialization; -using Elsa.Workflows.Serialization.Options; +using Elsa.Common.Serialization; namespace Elsa.Workflows.Serialization.Converters; @@ -12,9 +12,9 @@ public class PolymorphicDictionaryConverter : JsonConverter _objectConverter; /// - public PolymorphicDictionaryConverter(JsonSerializerOptions options, WorkflowJsonOptions workflowJsonOptions) + public PolymorphicDictionaryConverter(JsonSerializerOptions options, ISerializationTypeRegistry workflowJsonTypeRegistry) { - var factory = (JsonConverterFactory)(options.Converters.FirstOrDefault(x => x is PolymorphicObjectConverterFactory) ?? new PolymorphicObjectConverterFactory(workflowJsonOptions)); + var factory = (JsonConverterFactory)(options.Converters.FirstOrDefault(x => x is PolymorphicObjectConverterFactory) ?? new PolymorphicObjectConverterFactory(workflowJsonTypeRegistry)); _objectConverter = (JsonConverter)factory.CreateConverter(typeof(object), options)!; } diff --git a/src/modules/Elsa.Workflows.Core/Serialization/Converters/PolymorphicObjectConverter.cs b/src/modules/Elsa.Workflows.Core/Serialization/Converters/PolymorphicObjectConverter.cs index 6fd7d30aa..dd412376c 100644 --- a/src/modules/Elsa.Workflows.Core/Serialization/Converters/PolymorphicObjectConverter.cs +++ b/src/modules/Elsa.Workflows.Core/Serialization/Converters/PolymorphicObjectConverter.cs @@ -5,11 +5,9 @@ using System.Text.Json; using System.Text.Json.Nodes; using System.Text.Json.Serialization; using Elsa.Extensions; -using Elsa.Workflows.Serialization.Helpers; -using Elsa.Workflows.Serialization.Options; using Elsa.Workflows.Serialization.ReferenceHandlers; -using Microsoft.Extensions.Options; using Newtonsoft.Json.Linq; +using Elsa.Common.Serialization; namespace Elsa.Workflows.Serialization.Converters; @@ -24,30 +22,22 @@ public class PolymorphicObjectConverter : JsonConverter private const string IdPropertyName = "$id"; private const string RefPropertyName = "$ref"; private const string ValuesPropertyName = "$values"; - private readonly WorkflowJsonOptions _workflowJsonOptions; + private readonly ISerializationTypeRegistry _workflowJsonTypeRegistry; /// /// Initializes a new instance of the class. /// - public PolymorphicObjectConverter(IOptions workflowJsonOptions) - : this(workflowJsonOptions.Value) + public PolymorphicObjectConverter(ISerializationTypeRegistry workflowJsonTypeRegistry) { - } - - /// - /// Initializes a new instance of the class. - /// - public PolymorphicObjectConverter(WorkflowJsonOptions workflowJsonOptions) - { - _workflowJsonOptions = workflowJsonOptions; + _workflowJsonTypeRegistry = workflowJsonTypeRegistry; } /// /// Initializes a new instance of the class. /// public PolymorphicObjectConverter() - : this(new WorkflowJsonOptions()) { + _workflowJsonTypeRegistry = SerializationTypeRegistry.CreateDefault(); } /// @@ -358,12 +348,14 @@ public class PolymorphicObjectConverter : JsonConverter } // If we found the _type property, attempt to resolve the type. - return typeName != null ? WorkflowJsonTypeResolver.ResolveType(_workflowJsonOptions, typeName, _workflowJsonOptions.AllowLegacyClrTypeNames) : default; + return typeName != null ? SerializationTypeResolver.ResolveType(_workflowJsonTypeRegistry, typeName) : default; } private void WriteTypeMetadata(Utf8JsonWriter writer, Type type) { - var typeAlias = WorkflowJsonTypeResolver.GetAliasOrLegacyClrTypeName(_workflowJsonOptions, type); + if (!SerializationTypeResolver.TryGetAlias(_workflowJsonTypeRegistry, type, out var typeAlias)) + return; + writer.WritePropertyName(TypePropertyName); writer.WriteStringValue(typeAlias); } @@ -376,7 +368,7 @@ public class PolymorphicObjectConverter : JsonConverter if (!targetType.IsInterface && !targetType.IsAbstract) return targetType; - if (WorkflowJsonTypeResolver.TryGetInstantiableCollectionType(targetType, out var instantiableCollectionType)) + if (SerializationTypeResolver.TryGetInstantiableCollectionType(targetType, out var instantiableCollectionType)) return instantiableCollectionType; throw new JsonException($"Workflow JSON type alias resolved to non-instantiable type '{targetType}'."); diff --git a/src/modules/Elsa.Workflows.Core/Serialization/Converters/PolymorphicObjectConverterFactory.cs b/src/modules/Elsa.Workflows.Core/Serialization/Converters/PolymorphicObjectConverterFactory.cs index d1994e820..0b7b73b69 100644 --- a/src/modules/Elsa.Workflows.Core/Serialization/Converters/PolymorphicObjectConverterFactory.cs +++ b/src/modules/Elsa.Workflows.Core/Serialization/Converters/PolymorphicObjectConverterFactory.cs @@ -1,8 +1,7 @@ using System.Dynamic; using System.Text.Json; using System.Text.Json.Serialization; -using Elsa.Workflows.Serialization.Options; -using Microsoft.Extensions.Options; +using Elsa.Common.Serialization; namespace Elsa.Workflows.Serialization.Converters; @@ -11,30 +10,22 @@ namespace Elsa.Workflows.Serialization.Converters; /// public class PolymorphicObjectConverterFactory : JsonConverterFactory { - private readonly WorkflowJsonOptions _workflowJsonOptions; + private readonly ISerializationTypeRegistry _workflowJsonTypeRegistry; /// /// A JSON converter factory that creates instances. /// - public PolymorphicObjectConverterFactory(IOptions workflowJsonOptions) - : this(workflowJsonOptions.Value) + public PolymorphicObjectConverterFactory(ISerializationTypeRegistry workflowJsonTypeRegistry) { - } - - /// - /// A JSON converter factory that creates instances. - /// - public PolymorphicObjectConverterFactory(WorkflowJsonOptions workflowJsonOptions) - { - _workflowJsonOptions = workflowJsonOptions; + _workflowJsonTypeRegistry = workflowJsonTypeRegistry; } /// /// Default constructor for use with attributes. /// public PolymorphicObjectConverterFactory() - : this(new WorkflowJsonOptions()) { + _workflowJsonTypeRegistry = SerializationTypeRegistry.CreateDefault(); } /// @@ -57,8 +48,8 @@ public class PolymorphicObjectConverterFactory : JsonConverterFactory public override JsonConverter CreateConverter(Type typeToConvert, JsonSerializerOptions options) { if (typeof(IDictionary).IsAssignableFrom(typeToConvert)) - return new PolymorphicDictionaryConverter(options, _workflowJsonOptions); + return new PolymorphicDictionaryConverter(options, _workflowJsonTypeRegistry); - return new PolymorphicObjectConverter(_workflowJsonOptions); + return new PolymorphicObjectConverter(_workflowJsonTypeRegistry); } } diff --git a/src/modules/Elsa.Workflows.Core/Serialization/Converters/TypeJsonConverter.cs b/src/modules/Elsa.Workflows.Core/Serialization/Converters/TypeJsonConverter.cs index 34165b414..cf2c03385 100644 --- a/src/modules/Elsa.Workflows.Core/Serialization/Converters/TypeJsonConverter.cs +++ b/src/modules/Elsa.Workflows.Core/Serialization/Converters/TypeJsonConverter.cs @@ -1,36 +1,34 @@ using System.Text.Json; using System.Text.Json.Serialization; -using Elsa.Workflows.Serialization.Helpers; -using Elsa.Workflows.Serialization.Options; +using Elsa.Extensions; using JetBrains.Annotations; -using Microsoft.Extensions.Options; +using Elsa.Common.Serialization; namespace Elsa.Workflows.Serialization.Converters; /// /// Serializes objects to a simple alias representing the type. +/// Unregistered types are written as metadata-only aliases and intentionally deserialize to instead of loading the original CLR type. /// [UsedImplicitly] public class TypeJsonConverter : JsonConverter { - private readonly WorkflowJsonOptions _workflowJsonOptions; + /// + /// Prefix for unregistered type metadata that is not used for CLR type loading during deserialization. + /// + private const string UnregisteredTypeAliasPrefix = "UnregisteredClrType:"; + private readonly ISerializationTypeRegistry _workflowJsonTypeRegistry; + + /// + public TypeJsonConverter(ISerializationTypeRegistry workflowJsonTypeRegistry) + { + _workflowJsonTypeRegistry = workflowJsonTypeRegistry; + } /// public TypeJsonConverter() - : this(new WorkflowJsonOptions()) { - } - - /// - public TypeJsonConverter(IOptions workflowJsonOptions) - : this(workflowJsonOptions.Value) - { - } - - /// - public TypeJsonConverter(WorkflowJsonOptions workflowJsonOptions) - { - _workflowJsonOptions = workflowJsonOptions; + _workflowJsonTypeRegistry = SerializationTypeRegistry.CreateDefault(); } /// @@ -43,14 +41,18 @@ public class TypeJsonConverter : JsonConverter public override Type? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) { var typeAlias = reader.GetString(); + if (typeAlias?.StartsWith(UnregisteredTypeAliasPrefix, StringComparison.Ordinal) == true) + return typeof(Exception); - return WorkflowJsonTypeResolver.ResolveType(_workflowJsonOptions, typeAlias, _workflowJsonOptions.AllowLegacyClrTypeNames); + return SerializationTypeResolver.ResolveType(_workflowJsonTypeRegistry, typeAlias); } /// public override void Write(Utf8JsonWriter writer, Type value, JsonSerializerOptions options) { - var typeAlias = WorkflowJsonTypeResolver.GetAliasOrLegacyClrTypeName(_workflowJsonOptions, value); + if (!SerializationTypeResolver.TryGetAlias(_workflowJsonTypeRegistry, value, out var typeAlias)) + typeAlias = $"{UnregisteredTypeAliasPrefix}{value.GetSimpleAssemblyQualifiedName()}"; + writer.WriteStringValue(typeAlias); } } diff --git a/src/modules/Elsa.Workflows.Core/Serialization/Converters/VariableConverter.cs b/src/modules/Elsa.Workflows.Core/Serialization/Converters/VariableConverter.cs index b5f7bf522..18184d4da 100644 --- a/src/modules/Elsa.Workflows.Core/Serialization/Converters/VariableConverter.cs +++ b/src/modules/Elsa.Workflows.Core/Serialization/Converters/VariableConverter.cs @@ -2,9 +2,8 @@ using System.Text.Json; using System.Text.Json.Serialization; using Elsa.Workflows.Memory; using Elsa.Workflows.Models; -using Elsa.Workflows.Serialization.Options; using Microsoft.Extensions.Logging; -using Microsoft.Extensions.Options; +using Elsa.Common.Serialization; namespace Elsa.Workflows.Serialization.Converters; @@ -18,16 +17,9 @@ public class VariableConverter : JsonConverter /// // ReSharper disable once ContextualLoggerProblem - public VariableConverter(ILogger logger) + public VariableConverter(ISerializationTypeRegistry workflowJsonTypeRegistry, ILogger logger) { - _mapper = new VariableMapper(logger); - } - - /// - // ReSharper disable once ContextualLoggerProblem - public VariableConverter(ILogger logger, IOptions workflowJsonOptions) - { - _mapper = new VariableMapper(logger, workflowJsonOptions); + _mapper = new VariableMapper(workflowJsonTypeRegistry, logger); } /// diff --git a/src/modules/Elsa.Workflows.Core/Serialization/Converters/VariableConverterFactory.cs b/src/modules/Elsa.Workflows.Core/Serialization/Converters/VariableConverterFactory.cs index 56971c510..f7aaab283 100644 --- a/src/modules/Elsa.Workflows.Core/Serialization/Converters/VariableConverterFactory.cs +++ b/src/modules/Elsa.Workflows.Core/Serialization/Converters/VariableConverterFactory.cs @@ -1,9 +1,8 @@ using System.Text.Json; using System.Text.Json.Serialization; using Elsa.Workflows.Memory; -using Elsa.Workflows.Serialization.Options; using Microsoft.Extensions.Logging; -using Microsoft.Extensions.Options; +using Elsa.Common.Serialization; namespace Elsa.Workflows.Serialization.Converters; @@ -12,31 +11,20 @@ namespace Elsa.Workflows.Serialization.Converters; /// public class VariableConverterFactory : JsonConverterFactory { + private readonly ISerializationTypeRegistry _workflowJsonTypeRegistry; private readonly ILoggerFactory _loggerFactory; - private readonly IOptions? _workflowJsonOptions; /// // ReSharper disable once ContextualLoggerProblem - public VariableConverterFactory(ILoggerFactory loggerFactory) + public VariableConverterFactory(ISerializationTypeRegistry workflowJsonTypeRegistry, ILoggerFactory loggerFactory) { + _workflowJsonTypeRegistry = workflowJsonTypeRegistry; _loggerFactory = loggerFactory; } - /// - // ReSharper disable once ContextualLoggerProblem - public VariableConverterFactory(ILoggerFactory loggerFactory, IOptions workflowJsonOptions) - { - _loggerFactory = loggerFactory; - _workflowJsonOptions = workflowJsonOptions; - } - /// public override bool CanConvert(Type typeToConvert) => typeof(Variable).IsAssignableFrom(typeToConvert); /// - public override JsonConverter CreateConverter(Type typeToConvert, JsonSerializerOptions options) - { - var logger = _loggerFactory.CreateLogger(); - return _workflowJsonOptions != null ? new VariableConverter(logger, _workflowJsonOptions) : new VariableConverter(logger); - } + public override JsonConverter CreateConverter(Type typeToConvert, JsonSerializerOptions options) => new VariableConverter(_workflowJsonTypeRegistry, _loggerFactory.CreateLogger()); } diff --git a/src/modules/Elsa.Workflows.Core/Serialization/Options/WorkflowJsonOptions.cs b/src/modules/Elsa.Workflows.Core/Serialization/Options/WorkflowJsonOptions.cs deleted file mode 100644 index 204257a52..000000000 --- a/src/modules/Elsa.Workflows.Core/Serialization/Options/WorkflowJsonOptions.cs +++ /dev/null @@ -1,91 +0,0 @@ -using System.Dynamic; -using System.Text.Json; -using System.Text.Json.Nodes; -using Elsa.Extensions; - -namespace Elsa.Workflows.Serialization.Options; - -/// -/// Options used by workflow JSON serializers to map stable type aliases to CLR types. -/// -public class WorkflowJsonOptions -{ - private readonly Dictionary _typesByAlias = new(StringComparer.OrdinalIgnoreCase); - private readonly Dictionary _aliasesByType = new(); - - /// - /// Initializes a new instance of the class. - /// - public WorkflowJsonOptions() - { - RegisterDefaultTypeAliases(); - } - - /// - /// Gets or sets a value indicating whether unrestricted CLR type names can be resolved for backwards compatibility. - /// - public bool AllowLegacyClrTypeNames { get; set; } = true; - - /// - /// Registers a type alias. - /// - public WorkflowJsonOptions RegisterTypeAlias(Type type, string alias) - { - _typesByAlias[alias] = type; - _aliasesByType[type] = alias; - - if (type.IsPrimitive || type.IsValueType && Nullable.GetUnderlyingType(type) == null) - { - var nullableType = typeof(Nullable<>).MakeGenericType(type); - var nullableAlias = alias + "?"; - _typesByAlias[nullableAlias] = nullableType; - _aliasesByType[nullableType] = nullableAlias; - } - - return this; - } - - /// - /// Attempts to resolve the specified alias to a type. - /// - public bool TryGetType(string alias, out Type type) => _typesByAlias.TryGetValue(alias, out type!); - - /// - /// Attempts to get the primary alias registered for the specified type. - /// - public bool TryGetAlias(Type type, out string alias) => _aliasesByType.TryGetValue(type, out alias!); - - /// - /// Lists all registered types. - /// - public IEnumerable ListTypes() => _typesByAlias.Values.Distinct(); - - private void RegisterDefaultTypeAliases() - { - this.AddTypeAlias("Int16"); - this.AddTypeAlias("Int32"); - this.AddTypeAlias("Int64"); - this.AddTypeAlias("Long"); - this.AddTypeAlias("Single"); - this.AddTypeAlias("Object"); - this.AddTypeAlias("String"); - this.AddTypeAlias("Boolean"); - this.AddTypeAlias("Decimal"); - this.AddTypeAlias("Double"); - this.AddTypeAlias("ByteArray"); - this.AddTypeAlias(); - this.AddTypeAlias(); - this.AddTypeAlias(); - this.AddTypeAlias(); - this.AddTypeAlias(); - this.AddTypeAlias("JSON"); - this.AddTypeAlias(); - this.AddTypeAlias(); - this.AddTypeAlias(); - this.AddTypeAlias(); - this.AddTypeAlias>("StringDictionary"); - this.AddTypeAlias>("ObjectDictionary"); - this.AddTypeAlias>("StringMap"); - this.AddTypeAlias>("ObjectMap"); - } -} diff --git a/src/modules/Elsa.Workflows.Core/Serialization/Serializers/BookmarkPayloadSerializer.cs b/src/modules/Elsa.Workflows.Core/Serialization/Serializers/BookmarkPayloadSerializer.cs index 60899d5c2..a2a79b631 100644 --- a/src/modules/Elsa.Workflows.Core/Serialization/Serializers/BookmarkPayloadSerializer.cs +++ b/src/modules/Elsa.Workflows.Core/Serialization/Serializers/BookmarkPayloadSerializer.cs @@ -1,7 +1,6 @@ using System.Text.Json; using Elsa.Workflows.Serialization.Converters; -using Elsa.Workflows.Serialization.Options; -using Microsoft.Extensions.Options; +using Elsa.Common.Serialization; namespace Elsa.Workflows.Serialization.Serializers; @@ -13,15 +12,7 @@ public class BookmarkPayloadSerializer : IBookmarkPayloadSerializer /// /// Initializes a new instance of the class. /// - public BookmarkPayloadSerializer() - : this(Microsoft.Extensions.Options.Options.Create(new WorkflowJsonOptions())) - { - } - - /// - /// Initializes a new instance of the class. - /// - public BookmarkPayloadSerializer(IOptions workflowJsonOptions) + public BookmarkPayloadSerializer(ISerializationTypeRegistry workflowJsonTypeRegistry) { _settings = new JsonSerializerOptions { @@ -30,7 +21,7 @@ public class BookmarkPayloadSerializer : IBookmarkPayloadSerializer PropertyNameCaseInsensitive = true, }; - _settings.Converters.Add(new TypeJsonConverter(workflowJsonOptions)); + _settings.Converters.Add(new TypeJsonConverter(workflowJsonTypeRegistry)); _settings.Converters.Add(new FuncExpressionValueConverter()); } diff --git a/src/modules/Elsa.Workflows.Core/Serialization/Serializers/JsonWorkflowStateSerializer.cs b/src/modules/Elsa.Workflows.Core/Serialization/Serializers/JsonWorkflowStateSerializer.cs index 989cf6265..93f8a807d 100644 --- a/src/modules/Elsa.Workflows.Core/Serialization/Serializers/JsonWorkflowStateSerializer.cs +++ b/src/modules/Elsa.Workflows.Core/Serialization/Serializers/JsonWorkflowStateSerializer.cs @@ -2,11 +2,9 @@ using System.Diagnostics.CodeAnalysis; using System.Text.Json; using Elsa.Common.Serialization; using Elsa.Workflows.Serialization.Converters; -using Elsa.Workflows.Serialization.Options; using Elsa.Workflows.Serialization.ReferenceHandlers; using Elsa.Workflows.State; using Microsoft.Extensions.Logging; -using Microsoft.Extensions.Options; namespace Elsa.Workflows.Serialization.Serializers; @@ -14,26 +12,18 @@ namespace Elsa.Workflows.Serialization.Serializers; /// Serializes and deserializes workflow states from and to JSON. /// public class JsonWorkflowStateSerializer : ConfigurableSerializer, IWorkflowStateSerializer - { - private readonly ILoggerFactory _loggerFactory; - private readonly IOptions _workflowJsonOptions; +{ + private readonly ISerializationTypeRegistry _workflowJsonTypeRegistry; + private readonly ILoggerFactory _loggerFactory; /// /// Initializes a new instance of the class. /// - public JsonWorkflowStateSerializer(IServiceProvider serviceProvider, ILoggerFactory loggerFactory) - : this(serviceProvider, loggerFactory, Microsoft.Extensions.Options.Options.Create(new WorkflowJsonOptions())) - { - } - - /// - /// Initializes a new instance of the class. - /// - public JsonWorkflowStateSerializer(IServiceProvider serviceProvider, ILoggerFactory loggerFactory, IOptions workflowJsonOptions) + public JsonWorkflowStateSerializer(IServiceProvider serviceProvider, ISerializationTypeRegistry workflowJsonTypeRegistry, ILoggerFactory loggerFactory) : base(serviceProvider) { + _workflowJsonTypeRegistry = workflowJsonTypeRegistry; _loggerFactory = loggerFactory; - _workflowJsonOptions = workflowJsonOptions; } /// @@ -144,9 +134,9 @@ public class JsonWorkflowStateSerializer : ConfigurableSerializer, IWorkflowStat /// protected override void AddConverters(JsonSerializerOptions options) { - options.Converters.Add(new TypeJsonConverter(_workflowJsonOptions)); - options.Converters.Add(new PolymorphicObjectConverterFactory(_workflowJsonOptions)); - options.Converters.Add(new VariableConverterFactory(_loggerFactory, _workflowJsonOptions)); + options.Converters.Add(new TypeJsonConverter(_workflowJsonTypeRegistry)); + options.Converters.Add(new PolymorphicObjectConverterFactory(_workflowJsonTypeRegistry)); + options.Converters.Add(new VariableConverterFactory(_workflowJsonTypeRegistry, _loggerFactory)); options.Converters.Add(new FuncExpressionValueConverter()); } } diff --git a/src/modules/Elsa.Workflows.Core/Serialization/Serializers/SafeSerializer.cs b/src/modules/Elsa.Workflows.Core/Serialization/Serializers/SafeSerializer.cs index 9a828338f..c2fadbd2a 100644 --- a/src/modules/Elsa.Workflows.Core/Serialization/Serializers/SafeSerializer.cs +++ b/src/modules/Elsa.Workflows.Core/Serialization/Serializers/SafeSerializer.cs @@ -71,9 +71,10 @@ public class SafeSerializer : ConfigurableSerializer, ISafeSerializer protected override void AddConverters(JsonSerializerOptions options) { var expressionDescriptorRegistry = ServiceProvider.GetRequiredService(); + var workflowJsonTypeRegistry = ServiceProvider.GetRequiredService(); options.Converters.Add(new JsonStringEnumConverter(JsonNamingPolicy.CamelCase)); - options.Converters.Add(CreateInstance()); + options.Converters.Add(new TypeJsonConverter(workflowJsonTypeRegistry)); options.Converters.Add(new SafeValueConverterFactory()); options.Converters.Add(new ExpressionJsonConverterFactory(expressionDescriptorRegistry)); options.Converters.Add(new FuncExpressionValueConverter()); diff --git a/src/modules/Elsa.Workflows.Core/Services/Hasher.cs b/src/modules/Elsa.Workflows.Core/Services/Hasher.cs index b80b373a8..be018cd7d 100644 --- a/src/modules/Elsa.Workflows.Core/Services/Hasher.cs +++ b/src/modules/Elsa.Workflows.Core/Services/Hasher.cs @@ -3,8 +3,7 @@ using System.Text; using System.Text.Json; using System.Text.Json.Serialization; using Elsa.Workflows.Serialization.Converters; -using Elsa.Workflows.Serialization.Options; -using Microsoft.Extensions.Options; +using Elsa.Common.Serialization; namespace Elsa.Workflows; @@ -13,12 +12,7 @@ public class Hasher : IHasher { private readonly JsonSerializerOptions _serializerOptions; - public Hasher() - : this(Microsoft.Extensions.Options.Options.Create(new WorkflowJsonOptions())) - { - } - - public Hasher(IOptions workflowJsonOptions) + public Hasher(ISerializationTypeRegistry workflowJsonTypeRegistry) { _serializerOptions = new JsonSerializerOptions { @@ -27,7 +21,7 @@ public class Hasher : IHasher DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull }; - _serializerOptions.Converters.Add(new TypeJsonConverter(workflowJsonOptions)); + _serializerOptions.Converters.Add(new TypeJsonConverter(workflowJsonTypeRegistry)); _serializerOptions.Converters.Add(new ExcludeFromHashConverterFactory()); } diff --git a/src/modules/Elsa.Workflows.Core/Services/VariableMapper.cs b/src/modules/Elsa.Workflows.Core/Services/VariableMapper.cs index cb4fc0019..430c746f1 100644 --- a/src/modules/Elsa.Workflows.Core/Services/VariableMapper.cs +++ b/src/modules/Elsa.Workflows.Core/Services/VariableMapper.cs @@ -2,11 +2,10 @@ using Elsa.Expressions.Helpers; using Elsa.Extensions; using Elsa.Workflows.Memory; using Elsa.Workflows.Models; -using Elsa.Workflows.Serialization.Helpers; -using Elsa.Workflows.Serialization.Options; +using Elsa.Workflows.Services; using Microsoft.Extensions.Logging; using Microsoft.Extensions.Logging.Abstractions; -using Microsoft.Extensions.Options; +using Elsa.Common.Serialization; namespace Elsa.Workflows; @@ -16,40 +15,21 @@ namespace Elsa.Workflows; public class VariableMapper { private readonly ILogger _logger; - private readonly WorkflowJsonOptions _workflowJsonOptions; + private readonly ISerializationTypeRegistry _workflowJsonTypeRegistry; /// /// Initializes a new instance of the class. /// + /// The serialization type registry. /// The logger. - public VariableMapper(ILogger logger) - : this(logger, Microsoft.Extensions.Options.Options.Create(new WorkflowJsonOptions())) - { - } - - /// - /// Initializes a new instance of the class. - /// - /// The logger. - /// The workflow JSON options. - public VariableMapper(ILogger logger, IOptions workflowJsonOptions) - : this(logger, workflowJsonOptions.Value) - { - } - - /// - /// Initializes a new instance of the class. - /// - /// The logger. - /// The workflow JSON options. - public VariableMapper(ILogger logger, WorkflowJsonOptions workflowJsonOptions) + public VariableMapper(ISerializationTypeRegistry workflowJsonTypeRegistry, ILogger logger) { + _workflowJsonTypeRegistry = workflowJsonTypeRegistry; _logger = logger; - _workflowJsonOptions = workflowJsonOptions; } /// - public VariableMapper() : this(NullLogger.Instance) + public VariableMapper() : this(SerializationTypeRegistry.CreateDefault(), NullLogger.Instance) { } @@ -60,6 +40,7 @@ public class VariableMapper public Variable Map(VariableModel source) { var type = ResolveVariableType(source.TypeName); + var variableGenericType = typeof(Variable<>).MakeGenericType(type); var variable = (Variable)Activator.CreateInstance(variableGenericType)!; @@ -84,19 +65,27 @@ public class VariableMapper var variableType = source.GetType(); var value = source.Value; var valueType = variableType.IsConstructedGenericType ? variableType.GetGenericArguments().FirstOrDefault() ?? typeof(object) : typeof(object); - var valueTypeAlias = WorkflowJsonTypeResolver.GetAliasOrLegacyClrTypeName(_workflowJsonOptions, valueType); - var storageDriverTypeName = source.StorageDriverType != null ? WorkflowJsonTypeResolver.GetAliasOrLegacyClrTypeName(_workflowJsonOptions, source.StorageDriverType) : null; + var valueTypeAlias = SerializationTypeResolver.TryGetAlias(_workflowJsonTypeRegistry, valueType, out var alias) ? alias : valueType.GetSimpleAssemblyQualifiedName(); + var storageDriverTypeName = GetTypeName(source.StorageDriverType); var serializedValue = value.Format(); return new(source.Id, source.Name, valueTypeAlias, serializedValue, storageDriverTypeName); } + private string? GetTypeName(Type? type) + { + if (type == null) + return null; + + return SerializationTypeResolver.TryGetAlias(_workflowJsonTypeRegistry, type, out var alias) ? alias : type.GetSimpleAssemblyQualifiedName(); + } + private Type ResolveVariableType(string? typeAlias) { if (string.IsNullOrWhiteSpace(typeAlias)) return typeof(object); - if (WorkflowJsonTypeResolver.TryResolveType(_workflowJsonOptions, typeAlias, _workflowJsonOptions.AllowLegacyClrTypeNames, out var type)) + if (SerializationTypeResolver.TryResolveType(_workflowJsonTypeRegistry, typeAlias, out var type)) return type; _logger.LogWarning("Failed to resolve variable type alias {VariableTypeName}", typeAlias); @@ -108,7 +97,7 @@ public class VariableMapper if (string.IsNullOrWhiteSpace(typeAlias)) return null; - if (WorkflowJsonTypeResolver.TryResolveType(_workflowJsonOptions, typeAlias, _workflowJsonOptions.AllowLegacyClrTypeNames, out var type) && IsStorageDriverType(type)) + if (SerializationTypeResolver.TryResolveType(_workflowJsonTypeRegistry, typeAlias, out var type) && IsStorageDriverType(type)) return type; _logger.LogWarning("Failed to resolve storage driver type alias {StorageDriverTypeName}", typeAlias); diff --git a/src/modules/Elsa.Workflows.Core/ShellFeatures/FlowchartFeature.cs b/src/modules/Elsa.Workflows.Core/ShellFeatures/FlowchartFeature.cs index 9efb4ce38..6307b5ae8 100644 --- a/src/modules/Elsa.Workflows.Core/ShellFeatures/FlowchartFeature.cs +++ b/src/modules/Elsa.Workflows.Core/ShellFeatures/FlowchartFeature.cs @@ -3,9 +3,10 @@ using Elsa.Extensions; using Elsa.Workflows.Activities.Flowchart.Models; using Elsa.Workflows.Activities.Flowchart.Options; using Elsa.Workflows.Activities.Flowchart.Serialization; -using Elsa.Workflows.Serialization.Options; +using Elsa.Workflows.Options; using JetBrains.Annotations; using Microsoft.Extensions.DependencyInjection; +using Elsa.Common.Serialization; namespace Elsa.Workflows.ShellFeatures; @@ -33,6 +34,6 @@ public class FlowchartFeature : IShellFeature if (FlowchartOptionsConfigurator != null) services.Configure(FlowchartOptionsConfigurator); - services.Configure(options => options.AddTypeAlias("FlowScope")); + services.Configure(options => options.AddTypeAlias("FlowScope")); } } diff --git a/src/modules/Elsa.Workflows.Core/ShellFeatures/WorkflowsFeature.cs b/src/modules/Elsa.Workflows.Core/ShellFeatures/WorkflowsFeature.cs index 04e3b6bc8..a9c6a065e 100644 --- a/src/modules/Elsa.Workflows.Core/ShellFeatures/WorkflowsFeature.cs +++ b/src/modules/Elsa.Workflows.Core/ShellFeatures/WorkflowsFeature.cs @@ -5,29 +5,33 @@ using Elsa.Common.ShellFeatures; using Elsa.Expressions.ShellFeatures; using Elsa.Extensions; using Elsa.Workflows.ActivationValidators; +using Elsa.Workflows.Activities.Flowchart.Models; using Elsa.Workflows.Activities.Flowchart.Options; using Elsa.Workflows.Activities.Flowchart.Serialization; using Elsa.Workflows.Builders; using Elsa.Workflows.CommitStates; +using Elsa.Workflows.Exceptions; using Elsa.Workflows.IncidentStrategies; using Elsa.Workflows.LogPersistence; using Elsa.Workflows.LogPersistence.Strategies; using Elsa.Workflows.Middleware.Activities; using Elsa.Workflows.Middleware.Workflows; +using Elsa.Workflows.Options; using Elsa.Workflows.Pipelines.ActivityExecution; using Elsa.Workflows.Pipelines.WorkflowExecution; using Elsa.Workflows.PortResolvers; using Elsa.Workflows.Serialization.Configurators; using Elsa.Workflows.Serialization.Helpers; -using Elsa.Workflows.Serialization.Options; using Elsa.Workflows.Serialization.Serializers; using Elsa.Workflows.Services; +using Elsa.Workflows.State; using Elsa.Workflows.UIHints.CheckList; using Elsa.Workflows.UIHints.Dictionary; using Elsa.Workflows.UIHints.Dropdown; using Elsa.Workflows.UIHints.JsonEditor; using Elsa.Workflows.UIHints.RadioList; using Microsoft.Extensions.DependencyInjection; +using Newtonsoft.Json.Linq; namespace Elsa.Workflows.ShellFeatures; @@ -84,7 +88,31 @@ public class WorkflowsFeature : IShellFeature public void ConfigureServices(IServiceCollection services) { - services.Configure(options => options.RegisterWorkflowTypeAliases()); + services.Configure(options => + { + options.AddTypeAlias(nameof(ExceptionState)); + options.AddTypeAlias(nameof(FaultException)); + options.AddTypeAlias(nameof(VariablesDictionary)); + options.AddTypeAlias(nameof(Token)); + options.RegisterLegacyTypeName(typeof(FlowJoinMode), "Elsa.Workflows.Core.Activities.Flowchart.Models.FlowJoinMode, Elsa.Workflows.Core"); + options.AddTypeAliasWithLegacyName(nameof(FlowJoinMode)); + options.AddTypeAliasWithLegacyName(nameof(WorkflowStorageDriver)); + options.AddTypeAliasWithLegacyName(nameof(WorkflowInstanceStorageDriver)); + options.AddTypeAliasWithLegacyName(nameof(MemoryStorageDriver)); + options.AddTypeAliasWithLegacyName(nameof(FaultStrategy)); + options.AddTypeAliasWithLegacyName(nameof(ContinueWithIncidentsStrategy)); + options.AddTypeAlias(nameof(Exception)); + options.AddTypeAlias(nameof(ArgumentException)); + options.AddTypeAlias(nameof(ArgumentNullException)); + options.AddTypeAlias(nameof(InvalidOperationException)); + options.AddTypeAlias(nameof(NullReferenceException)); + options.AddTypeAlias(nameof(OperationCanceledException)); + options.AddTypeAlias(nameof(TaskCanceledException)); + options.AddTypeAlias(nameof(TimeoutException)); + options.AddTypeAlias(nameof(NotSupportedException)); + options.AddTypeAlias(nameof(JObject)); + options.AddTypeAlias(nameof(JArray)); + }); services // Core. @@ -155,6 +183,7 @@ public class WorkflowsFeature : IShellFeature .AddStorageDriver() // Serialization. + .AddSingleton() .AddSingleton() .AddSingleton() .AddSingleton() @@ -192,7 +221,7 @@ public class WorkflowsFeature : IShellFeature // Logging .AddLogging(); - + // Overridable services services.AddScoped(); } diff --git a/src/modules/Elsa.Workflows.Management/Extensions/ManagementServiceCollectionExtensions.cs b/src/modules/Elsa.Workflows.Management/Extensions/ManagementServiceCollectionExtensions.cs index 8dbdc87e3..6b83d8e39 100644 --- a/src/modules/Elsa.Workflows.Management/Extensions/ManagementServiceCollectionExtensions.cs +++ b/src/modules/Elsa.Workflows.Management/Extensions/ManagementServiceCollectionExtensions.cs @@ -1,9 +1,10 @@ using System.Reflection; -using Elsa.Extensions; +using Elsa.Expressions.Extensions; using Elsa.Workflows.Management.Models; using Elsa.Workflows.Management.Options; -using Elsa.Workflows.Serialization.Options; +using Elsa.Workflows.Options; using Microsoft.Extensions.DependencyInjection; +using Elsa.Common.Serialization; // ReSharper disable once CheckNamespace namespace Elsa.Workflows.Management.Extensions; @@ -99,8 +100,9 @@ public static class ManagementServiceCollectionExtensions /// public static IServiceCollection AddVariableTypeAndAlias(this IServiceCollection services, string alias, string category) { + services.Configure(options => options.RegisterTypeAlias(typeof(T), alias)); return services .AddVariableDescriptor(category) - .Configure(options => options.AddTypeAlias(alias)); + .AddTypeAlias(alias); } } diff --git a/src/modules/Elsa.Workflows.Management/Extensions/ModuleExtensions.cs b/src/modules/Elsa.Workflows.Management/Extensions/ModuleExtensions.cs index be1d8ecba..36cc410ae 100644 --- a/src/modules/Elsa.Workflows.Management/Extensions/ModuleExtensions.cs +++ b/src/modules/Elsa.Workflows.Management/Extensions/ModuleExtensions.cs @@ -2,8 +2,9 @@ using Elsa.Features.Services; using Elsa.Workflows; using Elsa.Workflows.Activities; using Elsa.Workflows.Management.Features; -using Elsa.Workflows.Serialization.Options; +using Elsa.Workflows.Options; using Microsoft.Extensions.DependencyInjection; +using Elsa.Common.Serialization; // ReSharper disable once CheckNamespace namespace Elsa.Extensions; @@ -74,9 +75,11 @@ public static class ModuleExtensions /// public static IModule AddVariableTypeAndAlias(this IModule module, string alias, string category) { - module.UseWorkflowManagement(management => management.AddVariableType(category)); - module.Services.Configure(options => options.AddTypeAlias(alias)); - return module; + module.Services.Configure(options => options.RegisterTypeAlias(typeof(T), alias)); + + return module + .UseWorkflowManagement(management => management.AddVariableType(category)) + .AddTypeAlias(alias); } /// diff --git a/src/modules/Elsa.Workflows.Management/Extensions/WorkflowManagementFeatureExtensions.cs b/src/modules/Elsa.Workflows.Management/Extensions/WorkflowManagementFeatureExtensions.cs index 57801be2d..58ab08a73 100644 --- a/src/modules/Elsa.Workflows.Management/Extensions/WorkflowManagementFeatureExtensions.cs +++ b/src/modules/Elsa.Workflows.Management/Extensions/WorkflowManagementFeatureExtensions.cs @@ -1,8 +1,9 @@ using Elsa.Extensions; using Elsa.Workflows.Management.Features; -using Elsa.Workflows.Serialization.Options; +using Elsa.Workflows.Options; using JetBrains.Annotations; using Microsoft.Extensions.DependencyInjection; +using Elsa.Common.Serialization; namespace Elsa.Workflows.Management; @@ -17,7 +18,8 @@ public static class WorkflowManagementFeatureExtensions public static WorkflowManagementFeature AddVariableTypeAndAlias(this WorkflowManagementFeature management, string alias, string category) { management.AddVariableType(category); - management.Module.Services.Configure(options => options.AddTypeAlias(alias)); + management.Module.AddTypeAlias(alias); + management.Module.Services.Configure(options => options.RegisterTypeAlias(typeof(T), alias)); return management; } } diff --git a/src/modules/Elsa.Workflows.Management/Features/WorkflowManagementFeature.cs b/src/modules/Elsa.Workflows.Management/Features/WorkflowManagementFeature.cs index d6769d71f..0a26da083 100644 --- a/src/modules/Elsa.Workflows.Management/Features/WorkflowManagementFeature.cs +++ b/src/modules/Elsa.Workflows.Management/Features/WorkflowManagementFeature.cs @@ -8,7 +8,7 @@ using Elsa.Caching.Features; using Elsa.Common.Codecs; using Elsa.Common.Features; using Elsa.Expressions.Contracts; -using Elsa.Workflows.Serialization.Options; +using Elsa.Expressions.Options; using Elsa.Extensions; using Elsa.Features.Abstractions; using Elsa.Features.Attributes; @@ -27,10 +27,12 @@ using Elsa.Workflows.Management.Options; using Elsa.Workflows.Management.Providers; using Elsa.Workflows.Management.Services; using Elsa.Workflows.Management.Stores; +using Elsa.Workflows.Options; using Elsa.Workflows.Serialization.Serializers; using JetBrains.Annotations; using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection.Extensions; +using Elsa.Common.Serialization; namespace Elsa.Workflows.Management.Features; @@ -313,8 +315,9 @@ public class WorkflowManagementFeature(IModule module) : FeatureBase(module) options.IsReadOnlyMode = IsReadOnlyMode; }); + Services.Configure(options => options.RegisterTypeAlias(typeof(ClrWorkflowMaterializerContext), nameof(ClrWorkflowMaterializerContext))); + Services.Configure(options => options.RegisterTypeAlias(typeof(ClrWorkflowMaterializerContext), nameof(ClrWorkflowMaterializerContext))); Services.Configure(_ => { }); Services.Configure(_ => { }); - Services.Configure(options => options.RegisterTypeAlias(typeof(ClrWorkflowMaterializerContext), nameof(ClrWorkflowMaterializerContext))); } } diff --git a/src/modules/Elsa.Workflows.Management/Mappers/VariableDefinitionMapper.cs b/src/modules/Elsa.Workflows.Management/Mappers/VariableDefinitionMapper.cs index 0f6644630..80568cc9b 100644 --- a/src/modules/Elsa.Workflows.Management/Mappers/VariableDefinitionMapper.cs +++ b/src/modules/Elsa.Workflows.Management/Mappers/VariableDefinitionMapper.cs @@ -2,27 +2,24 @@ using Elsa.Expressions.Helpers; using Elsa.Extensions; using Elsa.Workflows.Memory; using Elsa.Workflows.Models; -using Elsa.Workflows.Serialization.Helpers; -using Elsa.Workflows.Serialization.Options; +using Elsa.Workflows.Services; using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.Logging; -using Microsoft.Extensions.Options; +using Elsa.Common.Serialization; namespace Elsa.Workflows.Management.Mappers; /// /// Maps s to s and vice versa. /// -public class VariableDefinitionMapper(IOptions workflowJsonOptions, IServiceScopeFactory scopeFactory, ILogger logger) +public class VariableDefinitionMapper(ISerializationTypeRegistry workflowJsonTypeRegistry, IServiceScopeFactory scopeFactory, ILogger logger) { - private readonly WorkflowJsonOptions _workflowJsonOptions = workflowJsonOptions.Value; - /// /// Maps a to a . /// public Variable? Map(VariableDefinition source) { - var type = WorkflowJsonTypeResolver.TryResolveType(_workflowJsonOptions, source.TypeName, _workflowJsonOptions.AllowLegacyClrTypeNames, out var resolvedType) ? resolvedType : null; + var type = SerializationTypeResolver.TryResolveType(workflowJsonTypeRegistry, source.TypeName, out var resolvedType) ? resolvedType : null; if (type == null) { @@ -72,10 +69,14 @@ public class VariableDefinitionMapper(IOptions workflowJson { var variableType = source.GetType(); var valueType = variableType.IsConstructedGenericType ? variableType.GetGenericArguments().FirstOrDefault() ?? typeof(object) : typeof(object); - var valueTypeAlias = WorkflowJsonTypeResolver.TryGetAlias(_workflowJsonOptions, valueType, out var alias) ? alias : null; + var valueTypeAlias = SerializationTypeResolver.TryGetAlias(workflowJsonTypeRegistry, valueType, out var alias) ? alias : null; var value = source.Value; var serializedValue = value.Format(); - var storageDriverTypeName = source.StorageDriverType != null ? WorkflowJsonTypeResolver.GetAliasOrLegacyClrTypeName(_workflowJsonOptions, source.StorageDriverType) : null; + var storageDriverTypeName = source.StorageDriverType != null + ? SerializationTypeResolver.TryGetAlias(workflowJsonTypeRegistry, source.StorageDriverType, out var storageDriverAlias) + ? storageDriverAlias + : source.StorageDriverType.GetSimpleAssemblyQualifiedName() + : null; // Handles the case where an alias exists for an array or collection type. E.g. byte[] -> ByteArray. if (valueTypeAlias != null && (valueType.IsArray || valueType.IsCollectionType())) @@ -84,7 +85,9 @@ public class VariableDefinitionMapper(IOptions workflowJson var isArray = valueType.IsArray; var isCollection = valueType.IsCollectionType(); var elementValueType = isArray ? valueType.GetElementType()! : isCollection ? valueType.GenericTypeArguments[0] : valueType; - var elementTypeAlias = WorkflowJsonTypeResolver.GetAliasOrLegacyClrTypeName(_workflowJsonOptions, elementValueType); + var elementTypeAlias = SerializationTypeResolver.TryGetAlias(workflowJsonTypeRegistry, elementValueType, out var elementAlias) + ? elementAlias + : elementValueType.GetSimpleAssemblyQualifiedName(); return new(source.Id, source.Name, elementTypeAlias, isArray, serializedValue, storageDriverTypeName); } @@ -99,7 +102,7 @@ public class VariableDefinitionMapper(IOptions workflowJson if (string.IsNullOrEmpty(storageDriverTypeName)) return null; - if (WorkflowJsonTypeResolver.TryResolveType(_workflowJsonOptions, storageDriverTypeName, _workflowJsonOptions.AllowLegacyClrTypeNames, out var type) && typeof(IStorageDriver).IsAssignableFrom(type)) + if (SerializationTypeResolver.TryResolveType(workflowJsonTypeRegistry, storageDriverTypeName, out var type) && typeof(IStorageDriver).IsAssignableFrom(type)) return type; // TODO: The following code handles backward compatibility with variable definitions referencing older .NET type namespaces. diff --git a/src/modules/Elsa.Workflows.Management/ShellFeatures/WorkflowManagementFeature.cs b/src/modules/Elsa.Workflows.Management/ShellFeatures/WorkflowManagementFeature.cs index 2622f6be7..b16f21d03 100644 --- a/src/modules/Elsa.Workflows.Management/ShellFeatures/WorkflowManagementFeature.cs +++ b/src/modules/Elsa.Workflows.Management/ShellFeatures/WorkflowManagementFeature.cs @@ -5,9 +5,9 @@ using CShells.Features; using Elsa.Caching.Features; using Elsa.Common.Features; using Elsa.Expressions.Contracts; -using Elsa.Workflows.Serialization.Options; using Elsa.Extensions; using Elsa.Features.Attributes; +using Elsa.Workflows.Options; using Elsa.Workflows.Features; using Elsa.Workflows.Management.Activities.WorkflowDefinitionActivity; using Elsa.Workflows.Management.Contracts; @@ -25,6 +25,7 @@ using Elsa.Workflows.Management.Stores; using Elsa.Workflows.Serialization.Serializers; using JetBrains.Annotations; using Microsoft.Extensions.DependencyInjection; +using Elsa.Common.Serialization; namespace Elsa.Workflows.Management.ShellFeatures; @@ -133,6 +134,6 @@ public class WorkflowManagementFeature : IShellFeature // Register the default variable descriptors declared on this feature. services.AddVariableDescriptors(VariableDescriptors); - services.Configure(options => options.RegisterTypeAlias(typeof(ClrWorkflowMaterializerContext), nameof(ClrWorkflowMaterializerContext))); + services.Configure(options => options.RegisterTypeAlias(typeof(ClrWorkflowMaterializerContext), nameof(ClrWorkflowMaterializerContext))); } } diff --git a/src/modules/Elsa.Workflows.Runtime/Comparers/WorkflowTriggerEqualityComparer.cs b/src/modules/Elsa.Workflows.Runtime/Comparers/WorkflowTriggerEqualityComparer.cs index 17a05faf8..dea87c00c 100644 --- a/src/modules/Elsa.Workflows.Runtime/Comparers/WorkflowTriggerEqualityComparer.cs +++ b/src/modules/Elsa.Workflows.Runtime/Comparers/WorkflowTriggerEqualityComparer.cs @@ -3,8 +3,8 @@ using System.Text.Json.Serialization; using System.Text.Json.Serialization.Metadata; using Elsa.Workflows.Runtime.Entities; using Elsa.Workflows.Serialization.Converters; -using Elsa.Workflows.Serialization.Options; -using Microsoft.Extensions.Options; +using Elsa.Workflows.Services; +using Elsa.Common.Serialization; namespace Elsa.Workflows.Runtime.Comparers; @@ -18,23 +18,14 @@ public class WorkflowTriggerEqualityComparer : IEqualityComparer /// /// Initializes a new instance of the class. /// - public WorkflowTriggerEqualityComparer() - : this(new WorkflowJsonOptions()) + public WorkflowTriggerEqualityComparer() : this(SerializationTypeRegistry.CreateDefault()) { } /// /// Initializes a new instance of the class. /// - public WorkflowTriggerEqualityComparer(IOptions workflowJsonOptions) - : this(workflowJsonOptions.Value) - { - } - - /// - /// Initializes a new instance of the class. - /// - public WorkflowTriggerEqualityComparer(WorkflowJsonOptions workflowJsonOptions) + public WorkflowTriggerEqualityComparer(ISerializationTypeRegistry workflowJsonTypeRegistry) { _settings = new() { @@ -53,8 +44,8 @@ public class WorkflowTriggerEqualityComparer : IEqualityComparer // polymorphic object properties serialize identically to their stored representation. _settings.Converters.Add(new JsonStringEnumConverter()); _settings.Converters.Add(JsonMetadataServices.TimeSpanConverter); - _settings.Converters.Add(new PolymorphicObjectConverterFactory(workflowJsonOptions)); - _settings.Converters.Add(new TypeJsonConverter(workflowJsonOptions)); + _settings.Converters.Add(new PolymorphicObjectConverterFactory(workflowJsonTypeRegistry)); + _settings.Converters.Add(new TypeJsonConverter(workflowJsonTypeRegistry)); } /// diff --git a/src/modules/Elsa.Workflows.Runtime/Extensions/DependencyInjectionExtensions.cs b/src/modules/Elsa.Workflows.Runtime/Extensions/DependencyInjectionExtensions.cs index 614c0d4c6..b99773b31 100644 --- a/src/modules/Elsa.Workflows.Runtime/Extensions/DependencyInjectionExtensions.cs +++ b/src/modules/Elsa.Workflows.Runtime/Extensions/DependencyInjectionExtensions.cs @@ -1,8 +1,8 @@ using System.Diagnostics.CodeAnalysis; using System.Reflection; -using Elsa.Workflows.Serialization.Options; using Elsa.Extensions; using Elsa.Workflows; +using Elsa.Workflows.Options; using Elsa.Workflows.Runtime; using Elsa.Workflows.Runtime.Contracts; using Elsa.Workflows.Runtime.Discovery; @@ -10,6 +10,7 @@ using Elsa.Workflows.Runtime.Options; using Elsa.Workflows.Runtime.Providers; using Microsoft.Extensions.DependencyInjection.Extensions; using Microsoft.Extensions.Options; +using Elsa.Common.Serialization; // ReSharper disable once CheckNamespace namespace Microsoft.Extensions.DependencyInjection; @@ -93,6 +94,6 @@ public static class DependencyInjectionExtensions private static void AddWorkflowRegistration(IServiceCollection services, Type workflowType) { services.PostConfigure(options => options.Workflows.Add(workflowType)); - services.Configure(options => options.RegisterTypeAlias(workflowType, workflowType.GetSimpleAssemblyQualifiedName())); + services.Configure(options => options.AddSimpleAssemblyQualifiedTypeAlias(workflowType)); } } diff --git a/src/modules/Elsa.Workflows.Runtime/Features/WorkflowRuntimeFeature.cs b/src/modules/Elsa.Workflows.Runtime/Features/WorkflowRuntimeFeature.cs index 8393bf829..9d50fe713 100644 --- a/src/modules/Elsa.Workflows.Runtime/Features/WorkflowRuntimeFeature.cs +++ b/src/modules/Elsa.Workflows.Runtime/Features/WorkflowRuntimeFeature.cs @@ -4,7 +4,6 @@ using Elsa.Common; using Elsa.Common.DistributedHosting; using Elsa.Common.Features; using Elsa.Common.RecurringTasks; -using Elsa.Workflows.Serialization.Options; using Elsa.Extensions; using Elsa.Features.Abstractions; using Elsa.Features.Attributes; @@ -14,13 +13,16 @@ using Elsa.Workflows.Features; using Elsa.Workflows.Management; using Elsa.Workflows.Management.Contracts; using Elsa.Workflows.Management.Services; +using Elsa.Workflows.Options; using Elsa.Workflows.Runtime.ActivationValidators; -using Elsa.Workflows.Runtime.Comparers; +using Elsa.Workflows.Runtime.Bookmarks; using Elsa.Workflows.Runtime.Discovery; using Elsa.Workflows.Runtime.Entities; using Elsa.Workflows.Runtime.Handlers; +using Elsa.Workflows.Runtime.Models; using Elsa.Workflows.Runtime.Options; using Elsa.Workflows.Runtime.Providers; +using Elsa.Workflows.Runtime.Stimuli; using Elsa.Workflows.Runtime.Stores; using Elsa.Workflows.Runtime.Tasks; using Elsa.Workflows.Runtime.UIHints; @@ -29,6 +31,7 @@ using Medallion.Threading.FileSystem; using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection.Extensions; using Microsoft.Extensions.Options; +using Elsa.Common.Serialization; namespace Elsa.Workflows.Runtime.Features; @@ -45,6 +48,7 @@ public class WorkflowRuntimeFeature(IModule module) : FeatureBase(module) /// A list of workflow builders configured during application startup. /// public IDictionary>> Workflows { get; set; } = new Dictionary>>(); + private ISet WorkflowTypes { get; } = new HashSet(); /// /// A factory that instantiates a concrete . @@ -200,7 +204,7 @@ public class WorkflowRuntimeFeature(IModule module) : FeatureBase(module) public WorkflowRuntimeFeature AddWorkflow(Type workflowType) { Workflows.Add(workflowType); - Services.Configure(options => options.RegisterTypeAlias(workflowType, workflowType.GetSimpleAssemblyQualifiedName())); + WorkflowTypes.Add(workflowType); return this; } @@ -267,6 +271,7 @@ public class WorkflowRuntimeFeature(IModule module) : FeatureBase(module) Services.Configure(WorkflowInboxCleanupOptions); Services.Configure(WorkflowDispatcherOptions); Services.Configure(BookmarkQueuePurgeOptions); + Services.Configure(RegisterWorkflowTypeAliases); Services.Configure(options => { options.Workflows = Workflows; }); Services.Configure(options => { @@ -305,7 +310,6 @@ public class WorkflowRuntimeFeature(IModule module) : FeatureBase(module) Services // Core. - .AddSingleton() .AddScoped() .AddScoped() .AddScoped() @@ -439,4 +443,34 @@ public class WorkflowRuntimeFeature(IModule module) : FeatureBase(module) Services.TryAddScoped(WorkflowDispatchOutboxStore); Services.TryAddScoped(); } + + private void RegisterWorkflowTypeAliases(SerializationTypeOptions options) + { + WorkflowRuntimeTypeAliasRegistrar.Register(options, GetRegisteredWorkflowTypes()); + } + + private IEnumerable GetRegisteredWorkflowTypes() + { + return WorkflowTypes + .Concat(Workflows.Keys.Select(TryResolveWorkflowType).Where(type => type != null).Select(type => type!)) + .Distinct(); + } + + private static Type? TryResolveWorkflowType(string typeName) + { + Type? type; + + try + { + type = Type.GetType(typeName, false); + } + catch (Exception e) when (e is ArgumentException or FileLoadException or FileNotFoundException or TypeLoadException or BadImageFormatException) + { + return null; + } + + return type != null && typeof(IWorkflow).IsAssignableFrom(type) && type is { IsAbstract: false, IsInterface: false, ContainsGenericParameters: false } + ? type + : null; + } } diff --git a/src/modules/Elsa.Workflows.Runtime/Services/TriggerIndexer.cs b/src/modules/Elsa.Workflows.Runtime/Services/TriggerIndexer.cs index b04d0f130..fa8c68c7a 100644 --- a/src/modules/Elsa.Workflows.Runtime/Services/TriggerIndexer.cs +++ b/src/modules/Elsa.Workflows.Runtime/Services/TriggerIndexer.cs @@ -15,6 +15,7 @@ using Medallion.Threading; using Microsoft.Extensions.Logging; using Microsoft.Extensions.Options; using Open.Linq.AsyncExtensions; +using Elsa.Common.Serialization; namespace Elsa.Workflows.Runtime; @@ -31,9 +32,9 @@ public class TriggerIndexer : ITriggerIndexer private readonly IServiceProvider _serviceProvider; private readonly IStimulusHasher _hasher; private readonly IDistributedLockProvider _distributedLockProvider; + private readonly WorkflowTriggerEqualityComparer _triggerEqualityComparer; private readonly DistributedLockingOptions _lockingOptions; private readonly ILogger _logger; - private readonly WorkflowTriggerEqualityComparer _triggerEqualityComparer; /// /// Constructor. @@ -49,8 +50,8 @@ public class TriggerIndexer : ITriggerIndexer IServiceProvider serviceProvider, IStimulusHasher hasher, IDistributedLockProvider distributedLockProvider, + ISerializationTypeRegistry workflowJsonTypeRegistry, IOptions lockingOptions, - WorkflowTriggerEqualityComparer triggerEqualityComparer, ILogger logger) { _activityVisitor = activityVisitor; @@ -62,8 +63,8 @@ public class TriggerIndexer : ITriggerIndexer _serviceProvider = serviceProvider; _hasher = hasher; _distributedLockProvider = distributedLockProvider; + _triggerEqualityComparer = new WorkflowTriggerEqualityComparer(workflowJsonTypeRegistry); _lockingOptions = lockingOptions.Value; - _triggerEqualityComparer = triggerEqualityComparer; _logger = logger; _workflowDefinitionService = workflowDefinitionService; } diff --git a/src/modules/Elsa.Workflows.Runtime/ShellFeatures/WorkflowRuntimeFeature.cs b/src/modules/Elsa.Workflows.Runtime/ShellFeatures/WorkflowRuntimeFeature.cs index d680b6529..1ec183a7e 100644 --- a/src/modules/Elsa.Workflows.Runtime/ShellFeatures/WorkflowRuntimeFeature.cs +++ b/src/modules/Elsa.Workflows.Runtime/ShellFeatures/WorkflowRuntimeFeature.cs @@ -3,15 +3,14 @@ using System.Reflection; using CShells.Features; using Elsa.Common; using Elsa.Common.RecurringTasks; -using Elsa.Workflows.Serialization.Options; using Elsa.Extensions; using Elsa.Mediator.Contracts; using Elsa.Workflows.CommitStates; using Elsa.Workflows.Management; using Elsa.Workflows.Management.Contracts; using Elsa.Workflows.Management.Services; +using Elsa.Workflows.Options; using Elsa.Workflows.Runtime.ActivationValidators; -using Elsa.Workflows.Runtime.Comparers; using Elsa.Workflows.Runtime.Discovery; using Elsa.Workflows.Runtime.Entities; using Elsa.Workflows.Runtime.Handlers; @@ -26,6 +25,7 @@ using Medallion.Threading.FileSystem; using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection.Extensions; using Microsoft.Extensions.Options; +using Elsa.Common.Serialization; namespace Elsa.Workflows.Runtime.ShellFeatures; @@ -185,7 +185,7 @@ public class WorkflowRuntimeFeature : IShellFeature public void ConfigureServices(IServiceCollection services) { // Options. - services.Configure(RegisterWorkflowTypeAliases); + services.Configure(RegisterWorkflowTypeAliases); services.Configure(options => { options.Workflows = Workflows; }); services.Configure(options => { @@ -227,7 +227,6 @@ public class WorkflowRuntimeFeature : IShellFeature .AddTransient() // Core. - .AddSingleton() .AddScoped() .AddScoped() .AddScoped() @@ -237,7 +236,6 @@ public class WorkflowRuntimeFeature : IShellFeature .AddScoped(StimulusDispatcher) .AddScoped(WorkflowCancellationDispatcher) .AddScoped(RunTaskDispatcher) - .AddScoped(DispatchWorkflowCommandHandler) .AddScoped(ActivityExecutionLogSink) .AddScoped(WorkflowExecutionLogSink) .AddSingleton(BackgroundActivityScheduler) @@ -364,9 +362,33 @@ public class WorkflowRuntimeFeature : IShellFeature services.TryAddScoped(); } - private void RegisterWorkflowTypeAliases(WorkflowJsonOptions options) + private void RegisterWorkflowTypeAliases(SerializationTypeOptions options) { - foreach (var workflowType in WorkflowTypes) - options.RegisterTypeAlias(workflowType, workflowType.GetSimpleAssemblyQualifiedName()); + WorkflowRuntimeTypeAliasRegistrar.Register(options, GetRegisteredWorkflowTypes()); + } + + private IEnumerable GetRegisteredWorkflowTypes() + { + return WorkflowTypes + .Concat(Workflows.Keys.Select(TryResolveWorkflowType).Where(type => type != null).Select(type => type!)) + .Distinct(); + } + + private static Type? TryResolveWorkflowType(string typeName) + { + Type? type; + + try + { + type = Type.GetType(typeName, false); + } + catch (Exception e) when (e is ArgumentException or FileLoadException or FileNotFoundException or TypeLoadException or BadImageFormatException) + { + return null; + } + + return type != null && typeof(IWorkflow).IsAssignableFrom(type) && type is { IsAbstract: false, IsInterface: false, ContainsGenericParameters: false } + ? type + : null; } } diff --git a/src/modules/Elsa.Workflows.Runtime/WorkflowRuntimeTypeAliasRegistrar.cs b/src/modules/Elsa.Workflows.Runtime/WorkflowRuntimeTypeAliasRegistrar.cs new file mode 100644 index 000000000..31a52542d --- /dev/null +++ b/src/modules/Elsa.Workflows.Runtime/WorkflowRuntimeTypeAliasRegistrar.cs @@ -0,0 +1,36 @@ +using Elsa.Extensions; +using Elsa.Workflows; +using Elsa.Workflows.Options; +using Elsa.Workflows.Runtime.Bookmarks; +using Elsa.Workflows.Runtime.Stimuli; +using Elsa.Common.Serialization; + +namespace Elsa.Workflows.Runtime; + +internal static class WorkflowRuntimeTypeAliasRegistrar +{ + public static void Register(SerializationTypeOptions options, IEnumerable workflowTypes) + { + options.AddTypeAlias(); + options.AddTypeAlias(); + options.AddTypeAlias(); + options.AddTypeAlias(); + options.AddTypeAlias(); + options.AddTypeAlias(); + options.AddTypeAlias(); + options.AddTypeAlias(); + options.AddTypeAlias(); + options.AddTypeAlias(); + options.AddTypeAlias(); + options.AddTypeAlias(); + options.AddTypeAlias(); + + foreach (var workflowType in workflowTypes.Where(IsConcreteWorkflowType).Distinct()) + options.RegisterTypeAlias(workflowType, workflowType.GetSimpleAssemblyQualifiedName()); + } + + private static bool IsConcreteWorkflowType(Type type) + { + return typeof(IWorkflow).IsAssignableFrom(type) && type is { IsAbstract: false, IsInterface: false, ContainsGenericParameters: false }; + } +} diff --git a/test/integration/Elsa.Workflows.IntegrationTests/Serialization/JsonSerialization/Tests.cs b/test/integration/Elsa.Workflows.IntegrationTests/Serialization/JsonSerialization/Tests.cs index e8e6343a9..1953f511e 100644 --- a/test/integration/Elsa.Workflows.IntegrationTests/Serialization/JsonSerialization/Tests.cs +++ b/test/integration/Elsa.Workflows.IntegrationTests/Serialization/JsonSerialization/Tests.cs @@ -1,5 +1,7 @@ using System.Text.Json; using System.Text.Json.Nodes; +using Elsa.Common.Serialization; +using Elsa.Extensions; using Elsa.Testing.Shared; using Microsoft.Extensions.DependencyInjection; using Newtonsoft.Json.Linq; @@ -9,7 +11,9 @@ namespace Elsa.Workflows.IntegrationTests.Serialization.JsonSerialization; public class SerializationTests(ITestOutputHelper testOutputHelper) { - private readonly IServiceProvider _services = new TestApplicationBuilder(testOutputHelper).Build(); + private readonly IServiceProvider _services = new TestApplicationBuilder(testOutputHelper) + .ConfigureServices(services => services.Configure(options => options.AddTypeAlias())) + .Build(); [Theory(DisplayName = "write")] [InlineData(typeof(JsonObject), "JsonObjectIsland")] @@ -182,4 +186,4 @@ public class SerializationTests(ITestOutputHelper testOutputHelper) public class TestObject { public string? Data { get; set; } -} \ No newline at end of file +} diff --git a/test/integration/Elsa.Workflows.IntegrationTests/Serialization/Polymorphism/Tests.cs b/test/integration/Elsa.Workflows.IntegrationTests/Serialization/Polymorphism/Tests.cs index fe1f0cd8d..a99897a4d 100644 --- a/test/integration/Elsa.Workflows.IntegrationTests/Serialization/Polymorphism/Tests.cs +++ b/test/integration/Elsa.Workflows.IntegrationTests/Serialization/Polymorphism/Tests.cs @@ -2,9 +2,11 @@ using System.Dynamic; using System.Text.Json; using System.Text.Json.Serialization; using System.Text.Json.Serialization.Metadata; +using Elsa.Workflows.Options; using Elsa.Workflows.Serialization.Converters; -using Elsa.Workflows.Serialization.Options; using Elsa.Workflows.Serialization.ReferenceHandlers; +using Elsa.Workflows.Services; +using Elsa.Common.Serialization; namespace Elsa.Workflows.IntegrationTests.Serialization.Polymorphism; @@ -14,7 +16,7 @@ public class Tests public void Test1() { var model = CreateModel(); - var expectedJson = File.ReadAllText("Serialization/Polymorphism/data.json").Trim(); + var expectedJson = File.ReadAllText("Serialization/Polymorphism/data.json").TrimEnd(); var actualJson = JsonSerializer.Serialize(model, GetSerializerOptions()); Assert.Equal(expectedJson, actualJson); } @@ -74,6 +76,10 @@ public class Tests private JsonSerializerOptions GetSerializerOptions() { var referenceHandler = new CrossScopedReferenceHandler(); + var workflowJsonTypeRegistry = new SerializationTypeRegistry(Microsoft.Extensions.Options.Options.Create(new SerializationTypeOptions())); + workflowJsonTypeRegistry.RegisterType(typeof(Model), nameof(Model)); + workflowJsonTypeRegistry.RegisterType(typeof(CustomDictionary), nameof(CustomDictionary)); + var options = new JsonSerializerOptions { ReferenceHandler = referenceHandler, @@ -84,7 +90,7 @@ public class Tests options.Converters.Add(new JsonStringEnumConverter()); options.Converters.Add(JsonMetadataServices.TimeSpanConverter); - options.Converters.Add(new PolymorphicObjectConverterFactory(new WorkflowJsonOptions())); + options.Converters.Add(new PolymorphicObjectConverterFactory(workflowJsonTypeRegistry)); return options; } diff --git a/test/integration/Elsa.Workflows.IntegrationTests/Serialization/Polymorphism/data.json b/test/integration/Elsa.Workflows.IntegrationTests/Serialization/Polymorphism/data.json index 623a5cacc..35109c75a 100644 --- a/test/integration/Elsa.Workflows.IntegrationTests/Serialization/Polymorphism/data.json +++ b/test/integration/Elsa.Workflows.IntegrationTests/Serialization/Polymorphism/data.json @@ -1 +1 @@ -{"$id":"1","text":"Hello World","number":123,"flag":true,"items":{"$id":"2","$values":[{"$id":"3","text":"Hello","number":1,"flag":true,"items":{"$id":"4","$values":[{"$id":"5","number":0,"flag":false,"metadata":{"Foo":"Bar","Number":123,"Flag":true,"Models":{"$id":"6","$values":[{"$id":"7","text":"Hello","number":1,"flag":true,"metadata":{"Foo":"Bar","Number":123,"Flag":true,"Models":{"$ref":"6"},"CustomDictionary":{"$id":"8","content-type":["application/json"],"_type":"Elsa.Workflows.IntegrationTests.Serialization.Polymorphism.CustomDictionary, Elsa.Workflows.IntegrationTests"}}},{"$id":"9","text":"World","number":2,"flag":false}],"_type":"System.Collections.Generic.List\u00601[[Elsa.Workflows.IntegrationTests.Serialization.Polymorphism.Model, Elsa.Workflows.IntegrationTests]], System.Private.CoreLib"},"CustomDictionary":{"$ref":"8"}}}]}},{"$id":"10","text":"World","number":2,"flag":false}]},"metadata":{"Foo":"Bar","Number":123,"Flag":true,"Models":{"$ref":"6"},"CustomDictionary":{"$ref":"8"}},"payload":{"$id":"11","text":"Payload","number":0,"flag":false,"_type":"Elsa.Workflows.IntegrationTests.Serialization.Polymorphism.Model, Elsa.Workflows.IntegrationTests"},"hashSet":{"$id":"12","$values":[{"$id":"13","text":"I\u0027m a model in a set!","number":0,"flag":false}],"_type":"System.Collections.Generic.HashSet\u00601[[Elsa.Workflows.IntegrationTests.Serialization.Polymorphism.Model, Elsa.Workflows.IntegrationTests]], System.Private.CoreLib"},"properties":{"$id":"14","Hello":{"$id":"15","text":"Hello","number":1,"flag":true},"World":{"$id":"16","text":"World","number":2,"flag":false}}} \ No newline at end of file +{"$id":"1","text":"Hello World","number":123,"flag":true,"items":{"$id":"2","$values":[{"$id":"3","text":"Hello","number":1,"flag":true,"items":{"$id":"4","$values":[{"$id":"5","number":0,"flag":false,"metadata":{"Foo":"Bar","Number":123,"Flag":true,"Models":{"$id":"6","$values":[{"$id":"7","text":"Hello","number":1,"flag":true,"metadata":{"Foo":"Bar","Number":123,"Flag":true,"Models":{"$ref":"6"},"CustomDictionary":{"$id":"8","content-type":["application/json"],"_type":"CustomDictionary"}}},{"$id":"9","text":"World","number":2,"flag":false}],"_type":"List\u003CModel\u003E"},"CustomDictionary":{"$ref":"8"}}}]}},{"$id":"10","text":"World","number":2,"flag":false}]},"metadata":{"Foo":"Bar","Number":123,"Flag":true,"Models":{"$ref":"6"},"CustomDictionary":{"$ref":"8"}},"payload":{"$id":"11","text":"Payload","number":0,"flag":false,"_type":"Model"},"hashSet":{"$id":"12","$values":[{"$id":"13","text":"I\u0027m a model in a set!","number":0,"flag":false}],"_type":"HashSet\u003CModel\u003E"},"properties":{"$id":"14","Hello":{"$id":"15","text":"Hello","number":1,"flag":true},"World":{"$id":"16","text":"World","number":2,"flag":false}}} diff --git a/test/unit/Elsa.Http.UnitTests/RateLimiting/IngressRateLimitingTests.cs b/test/unit/Elsa.Http.UnitTests/RateLimiting/IngressRateLimitingTests.cs index 4bdffea11..ec5eb2d7c 100644 --- a/test/unit/Elsa.Http.UnitTests/RateLimiting/IngressRateLimitingTests.cs +++ b/test/unit/Elsa.Http.UnitTests/RateLimiting/IngressRateLimitingTests.cs @@ -314,11 +314,15 @@ public class IngressRateLimitingTests app => app.UseWorkflowsApiRateLimiting("elsa/api", PolicyName), options => AddFixedWindowLimiter(options, "other")); - app.Configure(); - await app.StartAsync(); - var client = app.GetTestClient(); + var exception = await Record.ExceptionAsync(async () => + { + app.Configure(); + await app.StartAsync(); + var client = app.GetTestClient(); + await client.GetAsync("/elsa/api/ping"); + }); - await Assert.ThrowsAsync(() => client.GetAsync("/elsa/api/ping")); + Assert.IsType(exception); } [Fact] diff --git a/test/unit/Elsa.Workflows.Api.UnitTests/Endpoints/IncidentStrategies/ListTests.cs b/test/unit/Elsa.Workflows.Api.UnitTests/Endpoints/IncidentStrategies/ListTests.cs new file mode 100644 index 000000000..9bcbe5b90 --- /dev/null +++ b/test/unit/Elsa.Workflows.Api.UnitTests/Endpoints/IncidentStrategies/ListTests.cs @@ -0,0 +1,28 @@ +using Elsa.Extensions; +using Elsa.Workflows.Api.Endpoints.IncidentStrategies.List; +using Elsa.Workflows.IncidentStrategies; +using Elsa.Workflows.Options; +using Elsa.Workflows.Services; +using Elsa.Common.Serialization; + +namespace Elsa.Workflows.Api.UnitTests.Endpoints.IncidentStrategies; + +public class ListTests +{ + [Fact] + public async Task ExecuteAsync_ReturnsWorkflowJsonTypeIdentifier_ForIncidentStrategyTypeName() + { + var options = new SerializationTypeOptions(); + options.RegisterTypeAlias(typeof(ContinueWithIncidentsStrategy), nameof(ContinueWithIncidentsStrategy)); + options.RegisterLegacySimpleAssemblyQualifiedName(typeof(ContinueWithIncidentsStrategy)); + var registry = new SerializationTypeRegistry(Microsoft.Extensions.Options.Options.Create(options)); + var endpoint = new List([new ContinueWithIncidentsStrategy()], registry); + + var response = await endpoint.ExecuteAsync(CancellationToken.None); + + var descriptor = Assert.Single(response.Items); + Assert.Equal(nameof(ContinueWithIncidentsStrategy), descriptor.TypeName); + Assert.True(registry.TryGetType(typeof(ContinueWithIncidentsStrategy).GetSimpleAssemblyQualifiedName(), out var legacyType)); + Assert.Equal(typeof(ContinueWithIncidentsStrategy), legacyType); + } +} diff --git a/test/unit/Elsa.Workflows.Core.UnitTests/Serialization/Converters/ActivityJsonConverterTests.cs b/test/unit/Elsa.Workflows.Core.UnitTests/Serialization/Converters/ActivityJsonConverterTests.cs index c90ab0a78..7782aeb13 100644 --- a/test/unit/Elsa.Workflows.Core.UnitTests/Serialization/Converters/ActivityJsonConverterTests.cs +++ b/test/unit/Elsa.Workflows.Core.UnitTests/Serialization/Converters/ActivityJsonConverterTests.cs @@ -1,5 +1,6 @@ using System.Text.Json; using Elsa.Common.Serialization; +using Elsa.Expressions.Services; using Elsa.Workflows.Activities; using Elsa.Workflows.Helpers; using Elsa.Workflows.Management.Activities.WorkflowDefinitionActivity; @@ -8,7 +9,6 @@ using Elsa.Workflows.Models; using Elsa.Workflows.Serialization.Configurators; using Elsa.Workflows.Serialization.Converters; using Elsa.Workflows.Serialization.Helpers; -using Elsa.Workflows.Serialization.Options; using Microsoft.Extensions.Logging; using NSubstitute; @@ -162,7 +162,7 @@ public sealed class ActivityJsonConverterTests Converters = { sut, - new TypeJsonConverter(new WorkflowJsonOptions()), + new TypeJsonConverter(), new PolymorphicObjectConverterFactory() }, TypeInfoResolver = new ModifiableJsonTypeInfoResolver(new CustomConstructorConfigurator().GetModifiers()) diff --git a/test/unit/Elsa.Workflows.Core.UnitTests/Serialization/Converters/SerializationTypeResolverTests.cs b/test/unit/Elsa.Workflows.Core.UnitTests/Serialization/Converters/SerializationTypeResolverTests.cs new file mode 100644 index 000000000..e392d6d09 --- /dev/null +++ b/test/unit/Elsa.Workflows.Core.UnitTests/Serialization/Converters/SerializationTypeResolverTests.cs @@ -0,0 +1,396 @@ +using System.Text.Json; +using System.Text.Json.Nodes; +using Elsa.Expressions.Options; +using Elsa.Expressions.Services; +using Elsa.Extensions; +using Elsa.Workflows.Exceptions; +using Elsa.Workflows.Memory; +using Elsa.Workflows.Options; +using Elsa.Workflows.Serialization.Converters; +using Elsa.Workflows.Services; +using Elsa.Workflows.State; +using Microsoft.Extensions.DependencyInjection; +using Newtonsoft.Json.Linq; +using Elsa.Common.Serialization; + +namespace Elsa.Workflows.Core.UnitTests.Serialization.Converters; + +public sealed class SerializationTypeResolverTests +{ + private static readonly string UnsafeAssemblyQualifiedTypeAlias = typeof(System.Text.StringBuilder).AssemblyQualifiedName!; + private readonly SerializationTypeRegistry _workflowJsonTypeRegistry = new(Microsoft.Extensions.Options.Options.Create(new SerializationTypeOptions())); + private readonly JsonSerializerOptions _options; + + public SerializationTypeResolverTests() + { + _workflowJsonTypeRegistry.RegisterType(typeof(ExceptionState), nameof(ExceptionState)); + _workflowJsonTypeRegistry.RegisterType(typeof(FaultException), nameof(FaultException)); + _workflowJsonTypeRegistry.RegisterType(typeof(RegisteredPayload), "RegisteredPayload"); + _options = CreateOptions(_workflowJsonTypeRegistry); + } + + [Theory] + [InlineData("String", typeof(string))] + [InlineData("String[]", typeof(string[]))] + [InlineData("String[][]", typeof(string[][]))] + [InlineData("List", typeof(List))] + [InlineData("List", typeof(List))] + [InlineData("List>", typeof(List>))] + [InlineData("ExceptionState", typeof(ExceptionState))] + [InlineData("FaultException", typeof(FaultException))] + [InlineData("ObjectDictionary", typeof(IDictionary))] + public void When_DeserializeRegisteredTypeAlias_Then_ReturnsExpectedType(string typeAlias, Type expectedType) + { + var result = JsonSerializer.Deserialize(JsonSerializer.Serialize(typeAlias), _options); + + Assert.Equal(expectedType, result); + } + + [Fact] + public void When_DeserializeRegisteredLegacyAssemblyQualifiedTypeAlias_Then_ReturnsExpectedType() + { + var typeAlias = typeof(RegisteredPayload).GetSimpleAssemblyQualifiedName(); + + var result = JsonSerializer.Deserialize(JsonString(typeAlias), _options); + + Assert.Equal(typeof(RegisteredPayload), result); + } + + [Fact] + public void When_DeserializeRegisteredTypeAliasWithDifferentCasing_Then_ReturnsExpectedType() + { + var result = JsonSerializer.Deserialize(JsonString("registeredpayload"), _options); + + Assert.Equal(typeof(RegisteredPayload), result); + } + + [Fact] + public void When_DeserializeRegisteredLegacyGenericCollectionTypeAlias_Then_ReturnsExpectedType() + { + var typeAlias = typeof(List).GetSimpleAssemblyQualifiedName(); + + var result = JsonSerializer.Deserialize(JsonString(typeAlias), _options); + + Assert.Equal(typeof(List), result); + } + + [Theory] + [InlineData(typeof(string), "String")] + [InlineData(typeof(string[]), "String[]")] + [InlineData(typeof(string[][]), "String[][]")] + [InlineData(typeof(List), "List")] + [InlineData(typeof(List), "List")] + [InlineData(typeof(List>), "List>")] + [InlineData(typeof(ExceptionState), "ExceptionState")] + [InlineData(typeof(FaultException), "FaultException")] + public void When_SerializeSupportedType_Then_EmitsAliasThatCanBeDeserialized(Type type, string expectedAlias) + { + var json = JsonSerializer.Serialize(type, _options); + var alias = JsonSerializer.Deserialize(json); + var result = JsonSerializer.Deserialize(json, _options); + + Assert.Equal(expectedAlias, alias); + Assert.Equal(type, result); + } + + [Theory] + [InlineData(typeof(IEnumerable), "List", typeof(List))] + [InlineData(typeof(ICollection), "List", typeof(List))] + [InlineData(typeof(IList), "List", typeof(List))] + [InlineData(typeof(IReadOnlyCollection), "List", typeof(List))] + [InlineData(typeof(IReadOnlyList), "List", typeof(List))] + [InlineData(typeof(ISet), "HashSet", typeof(HashSet))] + public void When_SerializeInterfaceCollectionType_Then_EmitsInstantiableAlias(Type type, string expectedAlias, Type expectedRoundTripType) + { + var json = JsonSerializer.Serialize(type, _options); + var alias = JsonSerializer.Deserialize(json); + var result = JsonSerializer.Deserialize(json, _options); + + Assert.Equal(expectedAlias, alias); + Assert.Equal(expectedRoundTripType, result); + } + + [Theory] + [MemberData(nameof(JsonIslandValues))] + public void When_SerializeSpecialJsonIslandType_Then_CanBeDeserialized(object value, Type expectedType) + { + _workflowJsonTypeRegistry.RegisterType(typeof(JObject), nameof(JObject)); + _workflowJsonTypeRegistry.RegisterType(typeof(JArray), nameof(JArray)); + + var json = JsonSerializer.Serialize(value, _options); + var result = JsonSerializer.Deserialize(json, _options); + + Assert.IsType(expectedType, result); + } + + [Theory] + [InlineData(typeof(System.Text.StringBuilder))] + [InlineData(typeof(System.Text.StringBuilder[]))] + [InlineData(typeof(List))] + public void When_SerializeUnsupportedType_Then_EmitsSafeUnregisteredTypeAlias(Type type) + { + var json = JsonSerializer.Serialize(type, _options); + var alias = JsonSerializer.Deserialize(json); + var result = JsonSerializer.Deserialize(json, _options); + + Assert.StartsWith("UnregisteredClrType:", alias); + Assert.Equal(typeof(Exception), result); + } + + [Fact] + public void When_SerializeExceptionStateWithUnregisteredExceptionType_Then_DoesNotThrow() + { + var exceptionState = ExceptionState.FromException(new NullReferenceException("Test")); + + var json = JsonSerializer.Serialize(exceptionState, _options); + var result = JsonSerializer.Deserialize(json, _options)!; + + Assert.Contains("UnregisteredClrType:", json); + Assert.Equal(typeof(Exception), result.Type); + Assert.Equal("Test", result.Message); + } + + [Fact] + public void When_ConfigureWorkflowsFeature_Then_RegistersCoreAliases() + { + var services = new ServiceCollection(); + var module = services.CreateModule(); + module.UseWorkflows(); + module.Apply(); + using var serviceProvider = services.BuildServiceProvider(); + var registry = serviceProvider.GetRequiredService(); + + var aliasRegistered = registry.TryGetAlias(typeof(NullReferenceException), out var alias); + var typeRegistered = registry.TryGetType(nameof(NullReferenceException), out var type); + + Assert.True(aliasRegistered); + Assert.Equal(nameof(NullReferenceException), alias); + Assert.True(typeRegistered); + Assert.Equal(typeof(NullReferenceException), type); + Assert.True(registry.TryGetAlias(typeof(MemoryStorageDriver), out var memoryStorageDriverAlias)); + Assert.Equal(nameof(MemoryStorageDriver), memoryStorageDriverAlias); + Assert.True(registry.TryGetType(nameof(MemoryStorageDriver), out var memoryStorageDriverType)); + Assert.Equal(typeof(MemoryStorageDriver), memoryStorageDriverType); + Assert.True(registry.TryGetType(typeof(MemoryStorageDriver).GetSimpleAssemblyQualifiedName(), out var legacyMemoryStorageDriverType)); + Assert.Equal(typeof(MemoryStorageDriver), legacyMemoryStorageDriverType); + Assert.True(registry.TryGetAlias(typeof(Elsa.Workflows.IncidentStrategies.ContinueWithIncidentsStrategy), out var incidentStrategyAlias)); + Assert.Equal(nameof(Elsa.Workflows.IncidentStrategies.ContinueWithIncidentsStrategy), incidentStrategyAlias); + Assert.True(registry.TryGetType(typeof(Elsa.Workflows.IncidentStrategies.ContinueWithIncidentsStrategy).GetSimpleAssemblyQualifiedName(), out var legacyIncidentStrategyType)); + Assert.Equal(typeof(Elsa.Workflows.IncidentStrategies.ContinueWithIncidentsStrategy), legacyIncidentStrategyType); + } + + [Fact] + public void When_TypeAliasExistsOnlyInExpressionOptions_Then_WorkflowJsonDoesNotResolveIt() + { + var expressionOptions = new ExpressionOptions(); + expressionOptions.RegisterTypeAlias(typeof(ExpressionOnlyPayload), "ExpressionOnlyPayload"); + var expressionRegistry = new WellKnownTypeRegistry(Microsoft.Extensions.Options.Options.Create(expressionOptions)); + + Assert.True(expressionRegistry.TryGetType("ExpressionOnlyPayload", out _)); + Assert.Throws(() => JsonSerializer.Deserialize(JsonString("ExpressionOnlyPayload"), _options)); + } + + [Fact] + public void When_SerializePolymorphicObjectWithUnregisteredType_Then_OmitsTypeMetadata() + { + var json = JsonSerializer.Serialize(new UnregisteredPayload { Name = "Alice" }, _options); + + var result = JsonSerializer.Deserialize(json, _options); + + Assert.DoesNotContain("\"_type\"", json); + var payload = Assert.IsAssignableFrom>(result); + Assert.Equal("Alice", payload["name"]); + } + + [Fact] + public void When_DeserializeUnknownAssemblyQualifiedTypeAlias_Then_ThrowsJsonException() + { + Assert.Throws(() => JsonSerializer.Deserialize(JsonString(UnsafeAssemblyQualifiedTypeAlias), _options)); + } + + [Fact] + public void When_DeserializeUnknownGenericElementTypeAlias_Then_ThrowsJsonException() + { + var typeAlias = $"List<{UnsafeAssemblyQualifiedTypeAlias}>"; + + Assert.Throws(() => JsonSerializer.Deserialize(JsonString(typeAlias), _options)); + } + + [Fact] + public void When_DeserializePolymorphicObjectWithRegisteredTypeAlias_Then_ReturnsTypedObject() + { + var json = """ + { + "name": "Alice", + "_type": "RegisteredPayload" + } + """; + + var result = JsonSerializer.Deserialize(json, _options); + + var payload = Assert.IsType(result); + Assert.Equal("Alice", payload.Name); + } + + [Theory] + [InlineData("IEnumerable", typeof(List))] + [InlineData("ICollection", typeof(List))] + [InlineData("IList", typeof(List))] + [InlineData("IReadOnlyCollection", typeof(List))] + [InlineData("IReadOnlyList", typeof(List))] + [InlineData("ISet", typeof(HashSet))] + public void When_DeserializePolymorphicCollectionInterface_Then_ReturnsConcreteCollection(string typeAlias, Type expectedType) + { + var json = $$""" + { + "_items": ["Alice"], + "_type": "{{typeAlias}}" + } + """; + + var result = JsonSerializer.Deserialize(json, _options); + + Assert.IsType(expectedType, result); + } + + [Fact] + public void When_DeserializePolymorphicObjectWithNonInstantiableType_Then_ThrowsJsonException() + { + _workflowJsonTypeRegistry.RegisterType(typeof(AbstractPayload), "AbstractPayload"); + var json = """ + { + "_type": "AbstractPayload" + } + """; + + Assert.Throws(() => JsonSerializer.Deserialize(json, _options)); + } + + [Fact] + public void When_DeserializePolymorphicObjectWithUnknownAssemblyQualifiedType_Then_ThrowsJsonException() + { + var json = $$""" + { + "capacity": 16, + "_type": {{JsonString(UnsafeAssemblyQualifiedTypeAlias)}} + } + """; + + Assert.Throws(() => JsonSerializer.Deserialize(json, _options)); + } + + [Fact] + public void When_DeserializePolymorphicObjectWithoutTypeJsonConverterAndUnknownAssemblyQualifiedType_Then_ThrowsJsonException() + { + var options = CreatePolymorphicOnlyOptions(_workflowJsonTypeRegistry); + var json = $$""" + { + "capacity": 16, + "_type": {{JsonString(UnsafeAssemblyQualifiedTypeAlias)}} + } + """; + + Assert.Throws(() => JsonSerializer.Deserialize(json, options)); + } + + [Fact] + public void When_DeserializeDictionaryObjectPayloadWithRegisteredTypeAlias_Then_ReturnsTypedObjectValue() + { + var json = """ + { + "payload": { + "name": "Alice", + "_type": "RegisteredPayload" + } + } + """; + + var result = JsonSerializer.Deserialize>(json, _options)!; + + var payload = Assert.IsType(result["payload"]); + Assert.Equal("Alice", payload.Name); + } + + [Fact] + public void When_DeserializeDictionaryObjectPayloadWithUnknownAssemblyQualifiedType_Then_ThrowsJsonException() + { + var json = $$""" + { + "payload": { + "capacity": 16, + "_type": {{JsonString(UnsafeAssemblyQualifiedTypeAlias)}} + } + } + """; + + Assert.Throws(() => JsonSerializer.Deserialize>(json, _options)); + } + + [Fact] + public void When_RegistryChangesAfterLegacyResolutionAttempt_Then_LegacyResolutionUsesCurrentRegistry() + { + var typeAlias = typeof(LateRegisteredPayload).GetSimpleAssemblyQualifiedName(); + Assert.False(SerializationTypeResolver.TryResolveType(_workflowJsonTypeRegistry, typeAlias, out _)); + + _workflowJsonTypeRegistry.RegisterType(typeof(LateRegisteredPayload), "LateRegisteredPayload"); + + Assert.True(SerializationTypeResolver.TryResolveType(_workflowJsonTypeRegistry, typeAlias, out var result)); + Assert.Equal(typeof(LateRegisteredPayload), result); + } + + private static JsonSerializerOptions CreateOptions(ISerializationTypeRegistry workflowJsonTypeRegistry) => new() + { + PropertyNamingPolicy = JsonNamingPolicy.CamelCase, + PropertyNameCaseInsensitive = true, + Converters = + { + new PolymorphicObjectConverterFactory(workflowJsonTypeRegistry), + new TypeJsonConverter(workflowJsonTypeRegistry) + } + }; + + private static JsonSerializerOptions CreatePolymorphicOnlyOptions(ISerializationTypeRegistry workflowJsonTypeRegistry) => new() + { + PropertyNamingPolicy = JsonNamingPolicy.CamelCase, + PropertyNameCaseInsensitive = true, + Converters = + { + new PolymorphicObjectConverterFactory(workflowJsonTypeRegistry) + } + }; + + private static string JsonString(string value) => JsonSerializer.Serialize(value); + + public static TheoryData JsonIslandValues() => new() + { + { new JObject { ["name"] = "Alice" }, typeof(JObject) }, + { new JArray("Alice", "Bob"), typeof(JArray) }, + { new JsonObject { ["name"] = "Alice" }, typeof(JsonObject) }, + { new JsonArray("Alice", "Bob"), typeof(JsonArray) } + }; + + public sealed class RegisteredPayload + { + public string? Name { get; set; } + } + + public sealed class UnregisteredPayload + { + public string? Name { get; set; } + } + + public abstract class AbstractPayload + { + public string? Name { get; set; } + } + + public sealed class LateRegisteredPayload + { + public string? Name { get; set; } + } + + public sealed class ExpressionOnlyPayload + { + public string? Name { get; set; } + } +} diff --git a/test/unit/Elsa.Workflows.Core.UnitTests/Serialization/Converters/WorkflowJsonTypeResolverTests.cs b/test/unit/Elsa.Workflows.Core.UnitTests/Serialization/Converters/WorkflowJsonTypeResolverTests.cs deleted file mode 100644 index 71f2b1396..000000000 --- a/test/unit/Elsa.Workflows.Core.UnitTests/Serialization/Converters/WorkflowJsonTypeResolverTests.cs +++ /dev/null @@ -1,268 +0,0 @@ -using System.Text.Json; -using Elsa.Expressions.Models; -using Elsa.Extensions; -using Elsa.Workflows.Activities.Flowchart.Models; -using Elsa.Workflows.Exceptions; -using Elsa.Workflows.IncidentStrategies; -using Elsa.Workflows.Models; -using Elsa.Workflows.Serialization.Converters; -using Elsa.Workflows.Serialization.Helpers; -using Elsa.Workflows.Serialization.Options; -using Microsoft.Extensions.DependencyInjection; -using Microsoft.Extensions.Options; - -namespace Elsa.Workflows.Core.UnitTests.Serialization.Converters; - -public class WorkflowJsonTypeResolverTests -{ - private static readonly string UnsafeAssemblyQualifiedTypeAlias = typeof(System.Text.StringBuilder).AssemblyQualifiedName!; - private static readonly string TrustedAssemblyQualifiedTypeAlias = typeof(UnregisteredPayload).GetSimpleAssemblyQualifiedName(); - private readonly JsonSerializerOptions _options; - private readonly JsonSerializerOptions _strictOptions; - - public WorkflowJsonTypeResolverTests() - { - _options = CreateOptions(); - _strictOptions = CreateOptions(false); - } - - [Fact] - public void TypeJsonConverter_ResolvesClrAssemblyQualifiedType() - { - var result = JsonSerializer.Deserialize(JsonSerializer.Serialize(UnsafeAssemblyQualifiedTypeAlias), _options); - - Assert.Equal(typeof(System.Text.StringBuilder), result); - } - - [Fact] - public void TypeJsonConverter_RejectsUnregisteredClrAssemblyQualifiedType_WhenLegacyClrTypeNamesDisabled() - { - Assert.Throws(() => JsonSerializer.Deserialize(JsonSerializer.Serialize(UnsafeAssemblyQualifiedTypeAlias), _strictOptions)); - } - - [Fact] - public void TypeJsonConverter_ResolvesTrustedClrAssemblyQualifiedType() - { - var result = JsonSerializer.Deserialize(JsonSerializer.Serialize(TrustedAssemblyQualifiedTypeAlias), _options); - - Assert.Equal(typeof(UnregisteredPayload), result); - } - - [Fact] - public void TypeJsonConverter_ResolvesIncidentStrategyClrType() - { - var typeAlias = typeof(ContinueWithIncidentsStrategy).GetSimpleAssemblyQualifiedName(); - - var result = JsonSerializer.Deserialize(JsonSerializer.Serialize(typeAlias), _options); - - Assert.Equal(typeof(ContinueWithIncidentsStrategy), result); - } - - [Fact] - public void TypeJsonConverter_ResolvesFaultExceptionClrType() - { - var typeAlias = typeof(FaultException).GetSimpleAssemblyQualifiedName(); - - var result = JsonSerializer.Deserialize(JsonSerializer.Serialize(typeAlias), _options); - - Assert.Equal(typeof(FaultException), result); - } - - [Fact] - public void PolymorphicObjectConverter_ResolvesClrAssemblyQualifiedType() - { - var json = $$""" - { - "name": "Alice", - "_type": {{JsonSerializer.Serialize(typeof(UnregisteredPayload).GetSimpleAssemblyQualifiedName())}} - } - """; - - var result = JsonSerializer.Deserialize(json, _options); - - var payload = Assert.IsType(result); - Assert.Equal("Alice", payload.Name); - } - - [Fact] - public void PolymorphicObjectConverter_RejectsUnregisteredClrAssemblyQualifiedType_WhenLegacyClrTypeNamesDisabled() - { - var json = $$""" - { - "name": "Alice", - "_type": {{JsonSerializer.Serialize(typeof(UnregisteredPayload).GetSimpleAssemblyQualifiedName())}} - } - """; - - Assert.Throws(() => JsonSerializer.Deserialize(json, _strictOptions)); - } - - [Fact] - public void PolymorphicObjectConverter_ResolvesRegisteredTypeAlias() - { - var json = """ - { - "name": "Alice", - "_type": "RegisteredPayload" - } - """; - - var result = JsonSerializer.Deserialize(json, _options); - - var payload = Assert.IsType(result); - Assert.Equal("Alice", payload.Name); - } - - [Fact] - public void PolymorphicObjectConverter_WritesClrTypeMetadataForUnregisteredTypes() - { - var json = JsonSerializer.Serialize(new UnregisteredPayload { Name = "Alice" }, _options); - var result = JsonSerializer.Deserialize(json, _options); - - Assert.Contains("\"_type\"", json); - var payload = Assert.IsType(result); - Assert.Equal("Alice", payload.Name); - } - - [Fact] - public void PolymorphicObjectConverter_RejectsUnregisteredClrTypeMetadata_WhenLegacyClrTypeNamesDisabled() - { - Assert.Throws(() => JsonSerializer.Serialize(new UnregisteredPayload { Name = "Alice" }, _strictOptions)); - } - - [Fact] - public void TypeJsonConverter_WritesUnregisteredTypesAsClrTypeNames() - { - var json = JsonSerializer.Serialize(typeof(UnregisteredPayload), _options); - var alias = JsonSerializer.Deserialize(json); - var result = JsonSerializer.Deserialize(json, _options); - - Assert.Equal(typeof(UnregisteredPayload).GetSimpleAssemblyQualifiedName(), alias); - Assert.Equal(typeof(UnregisteredPayload), result); - } - - [Fact] - public void TypeJsonConverter_RejectsUnregisteredClrTypeMetadata_WhenLegacyClrTypeNamesDisabled() - { - Assert.Throws(() => JsonSerializer.Serialize(typeof(UnregisteredPayload), _strictOptions)); - } - - [Fact] - public void OutputJsonConverter_WritesUnregisteredTypesAsClrTypeNames() - { - var options = CreateOptions(); - options.Converters.Add(new OutputJsonConverter(Microsoft.Extensions.Options.Options.Create(new WorkflowJsonOptions()))); - var output = new Output(new MemoryBlockReference("result")); - - var json = JsonSerializer.Serialize(output, options); - - using var doc = JsonDocument.Parse(json); - Assert.Equal(typeof(UnregisteredPayload).GetSimpleAssemblyQualifiedName(), doc.RootElement.GetProperty("typeName").GetString()); - } - - [Fact] - public void OutputJsonConverter_RejectsUnregisteredClrTypeMetadata_WhenLegacyClrTypeNamesDisabled() - { - var workflowJsonOptions = new WorkflowJsonOptions - { - AllowLegacyClrTypeNames = false - }; - var options = CreateOptions(); - options.Converters.Add(new OutputJsonConverter(Microsoft.Extensions.Options.Options.Create(workflowJsonOptions))); - var output = new Output(new MemoryBlockReference("result")); - - Assert.Throws(() => JsonSerializer.Serialize(output, options)); - } - - [Fact] - public void TypeJsonConverter_ResolvesRegisteredLegacyAssemblyQualifiedName() - { - var typeAlias = typeof(RegisteredPayload).GetSimpleAssemblyQualifiedName(); - - var result = JsonSerializer.Deserialize(JsonSerializer.Serialize(typeAlias), _strictOptions); - - Assert.Equal(typeof(RegisteredPayload), result); - } - - [Fact] - public void TypeJsonConverter_ResolvesRegisteredAliasesCaseInsensitively() - { - var result = JsonSerializer.Deserialize(JsonSerializer.Serialize("registeredpayload"), _strictOptions); - - Assert.Equal(typeof(RegisteredPayload), result); - } - - [Fact] - public void TypeJsonConverter_WritesPreferredAlias_WhenTypeHasMultipleAliases() - { - var json = JsonSerializer.Serialize(typeof(FlowJoinMode), _strictOptions); - - Assert.Equal("\"FlowJoinMode\"", json); - } - - [Fact] - public void TypeJsonConverter_RoundTripsNullableValueTypeAliases_WhenLegacyClrTypeNamesDisabled() - { - var json = JsonSerializer.Serialize(typeof(int?), _strictOptions); - var result = JsonSerializer.Deserialize(JsonSerializer.Serialize("int32?"), _strictOptions); - - Assert.Equal("\"Int32?\"", json); - Assert.Equal(typeof(int?), result); - } - - [Fact] - public void ShellWorkflowsFeature_RegistersWorkflowJsonTypeAliases() - { - var services = new ServiceCollection(); - new Elsa.Workflows.ShellFeatures.WorkflowsFeature().ConfigureServices(services); - var workflowJsonOptions = services.BuildServiceProvider().GetRequiredService>().Value; - - var faultStrategy = WorkflowJsonTypeResolver.ResolveType(workflowJsonOptions, nameof(FaultStrategy), false); - - Assert.Equal(typeof(FaultStrategy), faultStrategy); - } - - [Fact] - public void ShellFlowchartFeature_RegistersFlowScopeTypeAlias() - { - var services = new ServiceCollection(); - new Elsa.Workflows.ShellFeatures.FlowchartFeature().ConfigureServices(services); - var workflowJsonOptions = services.BuildServiceProvider().GetRequiredService>().Value; - - var flowScope = WorkflowJsonTypeResolver.ResolveType(workflowJsonOptions, "FlowScope", false); - - Assert.Equal(typeof(FlowScope), flowScope); - } - - private JsonSerializerOptions CreateOptions(bool allowLegacyClrTypeNames = true) - { - var workflowJsonOptions = new WorkflowJsonOptions - { - AllowLegacyClrTypeNames = allowLegacyClrTypeNames - }; - workflowJsonOptions.RegisterWorkflowTypeAliases(); - workflowJsonOptions.RegisterTypeAlias(typeof(RegisteredPayload), "RegisteredPayload"); - workflowJsonOptions.RegisterTypeAlias(typeof(FaultStrategy), nameof(FaultStrategy)); - - return new() - { - PropertyNamingPolicy = JsonNamingPolicy.CamelCase, - PropertyNameCaseInsensitive = true, - Converters = - { - new PolymorphicObjectConverterFactory(workflowJsonOptions), - new TypeJsonConverter(workflowJsonOptions) - } - }; - } - - public sealed class RegisteredPayload - { - public string? Name { get; set; } - } - - public sealed class UnregisteredPayload - { - public string? Name { get; set; } - } -} diff --git a/test/unit/Elsa.Workflows.Core.UnitTests/Services/VariableMapperTests.cs b/test/unit/Elsa.Workflows.Core.UnitTests/Services/VariableMapperTests.cs index 62c6042ab..24dea445c 100644 --- a/test/unit/Elsa.Workflows.Core.UnitTests/Services/VariableMapperTests.cs +++ b/test/unit/Elsa.Workflows.Core.UnitTests/Services/VariableMapperTests.cs @@ -1,24 +1,24 @@ -using System.Text.Json; using Elsa.Extensions; using Elsa.Workflows.Memory; using Elsa.Workflows.Models; -using Elsa.Workflows.Serialization.Options; +using Elsa.Workflows.Options; using Elsa.Workflows.Services; using Microsoft.Extensions.Logging.Abstractions; +using Elsa.Common.Serialization; namespace Elsa.Workflows.Core.UnitTests.Services; public class VariableMapperTests { - private readonly WorkflowJsonOptions _workflowJsonOptions = new(); + private readonly SerializationTypeRegistry _registry = new(Microsoft.Extensions.Options.Options.Create(new SerializationTypeOptions())); private readonly VariableMapper _mapper; public VariableMapperTests() { - _workflowJsonOptions.RegisterTypeAlias(typeof(string), "String"); - _workflowJsonOptions.RegisterTypeAlias(typeof(WorkflowStorageDriver), nameof(WorkflowStorageDriver)); - _workflowJsonOptions.RegisterTypeAlias(typeof(MemoryStorageDriver), typeof(MemoryStorageDriver).GetSimpleAssemblyQualifiedName()); - _mapper = new(NullLogger.Instance, _workflowJsonOptions); + _registry.RegisterType(typeof(string), "String"); + _registry.RegisterType(typeof(WorkflowStorageDriver), nameof(WorkflowStorageDriver)); + _registry.RegisterType(typeof(MemoryStorageDriver), typeof(MemoryStorageDriver).GetSimpleAssemblyQualifiedName()); + _mapper = new(_registry, NullLogger.Instance); } [Fact] @@ -38,13 +38,21 @@ public class VariableMapperTests } [Fact] - public void Map_ResolvesRegisteredStorageDriverAssemblyQualifiedName() + public void Map_ResolvesRegisteredMemoryStorageDriverAssemblyQualifiedName() { var variable = _mapper.Map(new VariableModel("id", "name", "String", "value", typeof(MemoryStorageDriver).GetSimpleAssemblyQualifiedName())); Assert.Equal(typeof(MemoryStorageDriver), variable.StorageDriverType); } + [Fact] + public void Map_WritesRegisteredStorageDriverAlias() + { + var model = _mapper.Map(new Variable("name", "") { StorageDriverType = typeof(WorkflowStorageDriver) }); + + Assert.Equal(nameof(WorkflowStorageDriver), model.StorageDriverTypeName); + } + [Fact] public void Map_DoesNotLoadUnregisteredStorageDriverAssemblyQualifiedName() { @@ -56,37 +64,10 @@ public class VariableMapperTests [Fact] public void Map_DoesNotUseRegisteredNonStorageDriverAliasAsStorageDriver() { - _workflowJsonOptions.RegisterTypeAlias(typeof(string), "NotAStorageDriver"); + _registry.RegisterType(typeof(string), "NotAStorageDriver"); var variable = _mapper.Map(new VariableModel("id", "name", "String", "value", "NotAStorageDriver")); Assert.Null(variable.StorageDriverType); } - - [Fact] - public void Map_WritesUnregisteredVariableTypeAsClrTypeName() - { - var variable = new Variable("payload", new()); - - var model = _mapper.Map(variable); - - Assert.Equal(typeof(UnregisteredPayload).GetSimpleAssemblyQualifiedName(), model.TypeName); - } - - [Fact] - public void Map_RejectsUnregisteredVariableType_WhenLegacyClrTypeNamesDisabled() - { - var workflowJsonOptions = new WorkflowJsonOptions - { - AllowLegacyClrTypeNames = false - }; - var mapper = new VariableMapper(NullLogger.Instance, workflowJsonOptions); - var variable = new Variable("payload", new()); - - Assert.Throws(() => mapper.Map(variable)); - } - - private sealed class UnregisteredPayload - { - } } diff --git a/test/unit/Elsa.Workflows.Management.UnitTests/Mappers/VariableDefinitionMapperTests.cs b/test/unit/Elsa.Workflows.Management.UnitTests/Mappers/VariableDefinitionMapperTests.cs index 2a6ba1acb..8110b8d3d 100644 --- a/test/unit/Elsa.Workflows.Management.UnitTests/Mappers/VariableDefinitionMapperTests.cs +++ b/test/unit/Elsa.Workflows.Management.UnitTests/Mappers/VariableDefinitionMapperTests.cs @@ -1,51 +1,51 @@ -using System.Text.Json; using Elsa.Extensions; using Elsa.Workflows.Management.Mappers; using Elsa.Workflows.Memory; using Elsa.Workflows.Models; -using Elsa.Workflows.Serialization.Options; +using Elsa.Workflows.Options; +using Elsa.Workflows.Services; using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.Logging.Abstractions; using NSubstitute; +using Elsa.Common.Serialization; namespace Elsa.Workflows.Management.UnitTests.Mappers; public class VariableDefinitionMapperTests { private readonly IServiceScopeFactory _scopeFactory = Substitute.For(); - private readonly WorkflowJsonOptions _workflowJsonOptions = new(); + private readonly SerializationTypeOptions _workflowJsonTypeOptions = new(); private readonly VariableDefinitionMapper _mapper; public VariableDefinitionMapperTests() { - _workflowJsonOptions.RegisterTypeAlias(typeof(string), "String"); - _workflowJsonOptions.RegisterTypeAlias(typeof(MemoryStorageDriver), nameof(MemoryStorageDriver)); - _mapper = CreateMapper(_workflowJsonOptions); + _workflowJsonTypeOptions.RegisterTypeAlias(typeof(string), "String"); + _workflowJsonTypeOptions.RegisterTypeAlias(typeof(MemoryStorageDriver), nameof(MemoryStorageDriver)); + _mapper = CreateMapper(_workflowJsonTypeOptions); } [Fact] - public void Map_ResolvesUnregisteredClrTypeName_WhenLegacyClrTypeNamesEnabled() + public void Map_DoesNotResolveUnregisteredClrTypeName() { var definition = new VariableDefinition("id", "payload", typeof(UnregisteredPayload).GetSimpleAssemblyQualifiedName(), false, null, null); var variable = _mapper.Map(definition); - Assert.IsType>(variable); + Assert.Null(variable); } [Fact] - public void Map_DoesNotResolveUnregisteredClrTypeName_WhenLegacyClrTypeNamesDisabled() + public void Map_ResolvesRegisteredLegacyClrTypeName() { - var workflowJsonOptions = new WorkflowJsonOptions - { - AllowLegacyClrTypeNames = false - }; - var mapper = CreateMapper(workflowJsonOptions); + var workflowJsonTypeOptions = new SerializationTypeOptions(); + workflowJsonTypeOptions.RegisterTypeAlias(typeof(UnregisteredPayload), nameof(UnregisteredPayload)); + workflowJsonTypeOptions.RegisterLegacySimpleAssemblyQualifiedName(typeof(UnregisteredPayload)); + var mapper = CreateMapper(workflowJsonTypeOptions); var definition = new VariableDefinition("id", "payload", typeof(UnregisteredPayload).GetSimpleAssemblyQualifiedName(), false, null, null); var variable = mapper.Map(definition); - Assert.Null(variable); + Assert.IsType>(variable); } [Fact] @@ -59,21 +59,22 @@ public class VariableDefinitionMapperTests } [Fact] - public void Map_RejectsUnregisteredVariableType_WhenLegacyClrTypeNamesDisabled() + public void Map_WritesRegisteredVariableTypeAsAlias() { - var workflowJsonOptions = new WorkflowJsonOptions - { - AllowLegacyClrTypeNames = false - }; - var mapper = CreateMapper(workflowJsonOptions); + var workflowJsonTypeOptions = new SerializationTypeOptions(); + workflowJsonTypeOptions.RegisterTypeAlias(typeof(UnregisteredPayload), nameof(UnregisteredPayload)); + var mapper = CreateMapper(workflowJsonTypeOptions); var variable = new Variable("payload", new()); - Assert.Throws(() => mapper.Map(variable)); + var definition = mapper.Map(variable); + + Assert.Equal(nameof(UnregisteredPayload), definition.TypeName); } - private VariableDefinitionMapper CreateMapper(WorkflowJsonOptions workflowJsonOptions) + private VariableDefinitionMapper CreateMapper(SerializationTypeOptions workflowJsonTypeOptions) { - return new(Microsoft.Extensions.Options.Options.Create(workflowJsonOptions), _scopeFactory, NullLogger.Instance); + var workflowJsonTypeRegistry = new SerializationTypeRegistry(Microsoft.Extensions.Options.Options.Create(workflowJsonTypeOptions)); + return new(workflowJsonTypeRegistry, _scopeFactory, NullLogger.Instance); } private sealed class UnregisteredPayload diff --git a/test/unit/Elsa.Workflows.Management.UnitTests/Services/WorkflowDefinitionExporterRegressionTests.cs b/test/unit/Elsa.Workflows.Management.UnitTests/Services/WorkflowDefinitionExporterRegressionTests.cs index 5e7eba5d3..1fe4344ae 100644 --- a/test/unit/Elsa.Workflows.Management.UnitTests/Services/WorkflowDefinitionExporterRegressionTests.cs +++ b/test/unit/Elsa.Workflows.Management.UnitTests/Services/WorkflowDefinitionExporterRegressionTests.cs @@ -6,10 +6,11 @@ using Elsa.Workflows.Management.Filters; using Elsa.Workflows.Management.Mappers; using Elsa.Workflows.Management.Services; using Elsa.Workflows.Models; -using Elsa.Workflows.Serialization.Options; +using Elsa.Workflows.Services; using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.Logging.Abstractions; using NSubstitute; +using Elsa.Common.Serialization; namespace Elsa.Workflows.Management.UnitTests.Services; @@ -61,7 +62,8 @@ public class WorkflowDefinitionExporterRegressionTests { var activitySerializer = Substitute.For(); var scopeFactory = Substitute.For(); - var variableDefinitionMapper = new VariableDefinitionMapper(Microsoft.Extensions.Options.Options.Create(new WorkflowJsonOptions()), scopeFactory, NullLogger.Instance); + var workflowJsonTypeRegistry = SerializationTypeRegistry.CreateDefault(); + var variableDefinitionMapper = new VariableDefinitionMapper(workflowJsonTypeRegistry, scopeFactory, NullLogger.Instance); var workflowDefinitionMapper = new WorkflowDefinitionMapper(activitySerializer, _workflowDefinitionService, variableDefinitionMapper); var fileNameSanitizer = new DefaultFileNameSanitizer(); diff --git a/test/unit/Elsa.Workflows.Runtime.UnitTests/Comparers/WorkflowTriggerEqualityComparerTests.cs b/test/unit/Elsa.Workflows.Runtime.UnitTests/Comparers/WorkflowTriggerEqualityComparerTests.cs index d20a45359..c283566b1 100644 --- a/test/unit/Elsa.Workflows.Runtime.UnitTests/Comparers/WorkflowTriggerEqualityComparerTests.cs +++ b/test/unit/Elsa.Workflows.Runtime.UnitTests/Comparers/WorkflowTriggerEqualityComparerTests.cs @@ -1,10 +1,11 @@ using System.Text.Json; using System.Text.Json.Serialization; using Elsa.Workflows.Helpers; +using Elsa.Workflows.Options; using Elsa.Workflows.Runtime.Comparers; using Elsa.Workflows.Runtime.Entities; -using Elsa.Workflows.Serialization.Converters; -using Elsa.Workflows.Serialization.Options; +using Elsa.Workflows.Services; +using Elsa.Common.Serialization; namespace Elsa.Workflows.Runtime.UnitTests.Comparers; @@ -27,8 +28,8 @@ public class WorkflowTriggerEqualityComparerTests /// A simple payload class that mimics real trigger payloads like HttpEndpointBookmarkPayload. /// private record TestPayload(string Path, string Method); - - private record TypePayload(Type TargetType); + private record TypedPayload(Type PayloadType, object Value); + private record NestedPayload(string Name); [Fact(DisplayName = "Fresh and round-tripped triggers with identical logical content should be considered equal")] public void FreshAndRoundTrippedTriggers_ShouldBeEqual() @@ -41,7 +42,7 @@ public class WorkflowTriggerEqualityComparerTests var roundTrippedPayload = SimulatePayloadRoundTrip(freshPayload); var loadedTrigger = CreateTrigger("trigger-1", roundTrippedPayload); - var comparer = new WorkflowTriggerEqualityComparer(); + var comparer = new WorkflowTriggerEqualityComparer(CreateTypeRegistry()); // Act var areEqual = comparer.Equals(freshTrigger, loadedTrigger); @@ -72,7 +73,7 @@ public class WorkflowTriggerEqualityComparerTests var newTriggers = new List { freshTrigger }; // Act: this is exactly what TriggerIndexer.IndexTriggersInternalAsync does - var diff = Diff.For(currentTriggers, newTriggers, new WorkflowTriggerEqualityComparer()); + var diff = Diff.For(currentTriggers, newTriggers, new WorkflowTriggerEqualityComparer(CreateTypeRegistry())); // Assert: the diff should find no changes. // Before the fix, it reported Removed=[existingTrigger] and Added=[freshTrigger] @@ -82,22 +83,6 @@ public class WorkflowTriggerEqualityComparerTests Assert.Single(diff.Unchanged); } - [Fact(DisplayName = "Comparer should use configured type aliases when normalizing trigger payloads")] - public void FreshAndRoundTrippedTriggers_WithRegisteredTypeAlias_ShouldBeEqual() - { - var workflowJsonOptions = new WorkflowJsonOptions(); - workflowJsonOptions.RegisterTypeAlias(typeof(CustomAliasTarget), "CustomAlias"); - var payload = new TypePayload(typeof(CustomAliasTarget)); - var roundTrippedPayload = SimulatePayloadRoundTrip(payload, workflowJsonOptions); - var freshTrigger = CreateTrigger("trigger-1", payload); - var loadedTrigger = CreateTrigger("trigger-1", roundTrippedPayload); - var comparer = new WorkflowTriggerEqualityComparer(workflowJsonOptions); - - var areEqual = comparer.Equals(freshTrigger, loadedTrigger); - - Assert.True(areEqual); - } - [Fact(DisplayName = "Documents the underlying System.Text.Json casing behavior that necessitated the fix")] public void PayloadSerializationMismatch_ProducesDifferentJson() { @@ -126,6 +111,50 @@ public class WorkflowTriggerEqualityComparerTests Assert.Equal("{\"Path\":\"/api/test\",\"Method\":\"GET\"}", freshJson); Assert.Equal("{\"path\":\"/api/test\",\"method\":\"GET\"}", roundTrippedJson); } + + [Fact(DisplayName = "Comparer serializes typed payload properties using the registered type aliases")] + public void TypedPayloadProperties_ShouldSerializeWithRegisteredAliases() + { + var payload = new TypedPayload(typeof(NestedPayload), new NestedPayload("orders")); + var comparer = new WorkflowTriggerEqualityComparer(CreateTypeRegistry()); + var trigger = CreateTrigger("trigger-1", payload); + var expectedAliasPayload = JsonSerializer.Deserialize( + """ + { + "payloadType": "NestedPayload", + "value": { + "name": "orders", + "_type": "NestedPayload" + } + } + """, + PayloadSerializerOptions); + var assemblyQualifiedPayload = JsonSerializer.Deserialize( + $$""" + { + "payloadType": "{{typeof(NestedPayload).AssemblyQualifiedName}}", + "value": { + "name": "orders", + "_type": "{{typeof(NestedPayload).AssemblyQualifiedName}}" + } + } + """, + PayloadSerializerOptions); + var missingTypePayload = JsonSerializer.Deserialize( + """ + { + "payloadType": "NestedPayload", + "value": { + "name": "orders" + } + } + """, + PayloadSerializerOptions); + + Assert.True(comparer.Equals(trigger, CreateTrigger("trigger-2", expectedAliasPayload!))); + Assert.False(comparer.Equals(trigger, CreateTrigger("trigger-3", assemblyQualifiedPayload!))); + Assert.False(comparer.Equals(trigger, CreateTrigger("trigger-4", missingTypePayload!))); + } /// /// IPayloadSerializer options: camelCase with case-insensitive deserialization. @@ -162,20 +191,13 @@ public class WorkflowTriggerEqualityComparerTests return deserialized!; } - private static object SimulatePayloadRoundTrip(object payload, WorkflowJsonOptions workflowJsonOptions) + private static ISerializationTypeRegistry CreateTypeRegistry() { - var options = CreatePayloadSerializerOptions(workflowJsonOptions); - var json = JsonSerializer.Serialize(payload, options); - return JsonSerializer.Deserialize(json, options)!; - } - - private static JsonSerializerOptions CreatePayloadSerializerOptions(WorkflowJsonOptions workflowJsonOptions) - { - var options = new JsonSerializerOptions(PayloadSerializerOptions); - options.Converters.Add(new JsonStringEnumConverter()); - options.Converters.Add(new PolymorphicObjectConverterFactory(workflowJsonOptions)); - options.Converters.Add(new TypeJsonConverter(workflowJsonOptions)); - return options; + var registry = new SerializationTypeRegistry(Microsoft.Extensions.Options.Options.Create(new SerializationTypeOptions())); + registry.RegisterType(typeof(TestPayload), nameof(TestPayload)); + registry.RegisterType(typeof(TypedPayload), nameof(TypedPayload)); + registry.RegisterType(typeof(NestedPayload), nameof(NestedPayload)); + return registry; } /// @@ -198,6 +220,4 @@ public class WorkflowTriggerEqualityComparerTests Hash = hash, Payload = payload }; - - private sealed class CustomAliasTarget; } diff --git a/test/unit/Elsa.Workflows.Runtime.UnitTests/Features/WorkflowRuntimeFeatureTests.cs b/test/unit/Elsa.Workflows.Runtime.UnitTests/Features/WorkflowRuntimeFeatureTests.cs new file mode 100644 index 000000000..ea633c152 --- /dev/null +++ b/test/unit/Elsa.Workflows.Runtime.UnitTests/Features/WorkflowRuntimeFeatureTests.cs @@ -0,0 +1,214 @@ +using System.Reflection; +using Elsa.Features.Attributes; +using Elsa.Features.Services; +using Elsa.Extensions; +using Elsa.Workflows; +using Elsa.Workflows.Activities; +using Elsa.Workflows.Features; +using Elsa.Workflows.Options; +using Elsa.Workflows.Runtime.Options; +using Elsa.Workflows.Runtime.Providers; +using NSubstitute; +using RuntimeFeature = Elsa.Workflows.Runtime.Features.WorkflowRuntimeFeature; +using ShellRuntimeFeature = Elsa.Workflows.Runtime.ShellFeatures.WorkflowRuntimeFeature; +using Elsa.Common.Serialization; + +namespace Elsa.Workflows.Runtime.UnitTests.Features; + +public class WorkflowRuntimeFeatureTests +{ + private readonly RuntimeFeature _feature = new(Substitute.For()); + private readonly ShellRuntimeFeature _shellFeature = new(); + + [Fact] + public void AddWorkflow_Throws_WhenTypeDoesNotImplementWorkflow() + { + Assert.Throws(() => _feature.AddWorkflow(typeof(NotAWorkflow))); + } + + [Theory] + [MemberData(nameof(NonInstantiableWorkflowTypes))] + public void AddWorkflow_Throws_WhenWorkflowTypeIsNotInstantiable(Type workflowType) + { + Assert.Throws(() => _feature.AddWorkflow(workflowType)); + } + + [Fact] + public void ShellAddWorkflow_Throws_WhenTypeDoesNotImplementWorkflow() + { + Assert.Throws(() => _shellFeature.AddWorkflow(typeof(NotAWorkflow))); + } + + [Theory] + [MemberData(nameof(NonInstantiableWorkflowTypes))] + public void ShellAddWorkflow_Throws_WhenWorkflowTypeIsNotInstantiable(Type workflowType) + { + Assert.Throws(() => _shellFeature.AddWorkflow(workflowType)); + } + + [Fact] + public void AddWorkflow_AllowsClosedGenericWorkflowType() + { + var workflowType = typeof(GenericWorkflow); + + _feature.AddWorkflow(workflowType); + + Assert.Contains(workflowType.GetSimpleAssemblyQualifiedName(), _feature.Workflows.Keys); + Assert.Contains(workflowType.FullName!, _feature.Workflows.Keys); + } + + [Fact] + public void ShellAddWorkflow_AllowsClosedGenericWorkflowType() + { + var workflowType = typeof(GenericWorkflow); + + _shellFeature.AddWorkflow(workflowType); + + Assert.Contains(workflowType.GetSimpleAssemblyQualifiedName(), _shellFeature.Workflows.Keys); + Assert.Contains(workflowType.FullName!, _shellFeature.Workflows.Keys); + } + + [Fact] + public void WorkflowsAdd_RegistersWorkflowTypeAlias() + { + var workflowType = typeof(GenericWorkflow); + var options = new SerializationTypeOptions(); + + _feature.Workflows.Add(workflowType); + + RegisterWorkflowTypeAliases(_feature, options); + + Assert.Equal(workflowType, options.AliasTypeDictionary[workflowType.GetSimpleAssemblyQualifiedName()]); + } + + [Fact] + public void WorkflowsAdd_DoesNotThrow_WhenLegacyKeyAlreadyExists() + { + var workflowType = typeof(GenericWorkflow); + _feature.Workflows.Add(workflowType.FullName!, _ => new ValueTask(new GenericWorkflow())); + + _feature.Workflows.Add(workflowType); + + Assert.Contains(workflowType.GetSimpleAssemblyQualifiedName(), _feature.Workflows.Keys); + Assert.Contains(workflowType.FullName!, _feature.Workflows.Keys); + Assert.Same(_feature.Workflows[workflowType.FullName!], _feature.Workflows[workflowType.GetSimpleAssemblyQualifiedName()]); + } + + [Fact] + public async Task ClrWorkflowsProvider_MaterializesWorkflowOnce_WhenCanonicalAndLegacyKeysExist() + { + CountingWorkflow.CreatedCount = 0; + var builder = Substitute.For(); + var builderFactory = Substitute.For(); + var provider = new ClrWorkflowsProvider( + Microsoft.Extensions.Options.Options.Create(new RuntimeOptions { Workflows = _feature.Workflows }), + builderFactory, + Substitute.For()); + builderFactory.CreateBuilder().Returns(builder); + builder.BuildWorkflowAsync(Arg.Any()).Returns(new Workflow()); + + _feature.Workflows.Add(typeof(CountingWorkflow)); + var workflows = await provider.GetWorkflowsAsync(); + + Assert.Single(workflows); + Assert.Equal(1, CountingWorkflow.CreatedCount); + } + + [Fact] + public void ShellWorkflowsAdd_RegistersWorkflowTypeAlias() + { + var workflowType = typeof(GenericWorkflow); + var options = new SerializationTypeOptions(); + + _shellFeature.Workflows.Add(workflowType); + + RegisterWorkflowTypeAliases(_shellFeature, options); + + Assert.Equal(workflowType, options.AliasTypeDictionary[workflowType.GetSimpleAssemblyQualifiedName()]); + } + + [Fact] + public void WorkflowsAdd_Throws_WhenTypeDoesNotImplementWorkflow() + { + Assert.Throws(() => _feature.Workflows.Add(typeof(NotAWorkflow))); + } + + [Fact] + public void RuntimeFeature_DependsOnWorkflowsFeature() + { + var dependencyTypes = typeof(RuntimeFeature) + .GetCustomAttributes() + .Select(x => x.Type); + + Assert.Contains(typeof(WorkflowsFeature), dependencyTypes); + } + + [Fact] + public void RegisterWorkflowTypeAliases_RegistersOnlyTrackedWorkflowTypes() + { + var workflowType = typeof(GenericWorkflow); + var options = new SerializationTypeOptions(); + _feature.AddWorkflow(workflowType); + _feature.Workflows[typeof(NotAWorkflow).AssemblyQualifiedName!] = _ => new ValueTask(new GenericWorkflow()); + + RegisterWorkflowTypeAliases(_feature, options); + + Assert.Equal(workflowType, options.AliasTypeDictionary[workflowType.GetSimpleAssemblyQualifiedName()]); + Assert.DoesNotContain(typeof(NotAWorkflow).AssemblyQualifiedName!, options.AliasTypeDictionary.Keys); + } + + [Fact] + public void ShellRegisterWorkflowTypeAliases_RegistersOnlyTrackedWorkflowTypes() + { + var workflowType = typeof(GenericWorkflow); + var options = new SerializationTypeOptions(); + _shellFeature.AddWorkflow(workflowType); + _shellFeature.Workflows[typeof(NotAWorkflow).AssemblyQualifiedName!] = _ => new ValueTask(new GenericWorkflow()); + + RegisterWorkflowTypeAliases(_shellFeature, options); + + Assert.Equal(workflowType, options.AliasTypeDictionary[workflowType.GetSimpleAssemblyQualifiedName()]); + Assert.DoesNotContain(typeof(NotAWorkflow).AssemblyQualifiedName!, options.AliasTypeDictionary.Keys); + } + + public static TheoryData NonInstantiableWorkflowTypes() => new() + { + typeof(IWorkflow), + typeof(WorkflowBase), + typeof(GenericWorkflow<>) + }; + + private sealed class NotAWorkflow + { + } + + private sealed class GenericWorkflow : IWorkflow + { + public ValueTask BuildAsync(IWorkflowBuilder builder, CancellationToken cancellationToken = default) + { + return ValueTask.CompletedTask; + } + } + + public sealed class CountingWorkflow : IWorkflow + { + public static int CreatedCount { get; set; } + + public CountingWorkflow() + { + CreatedCount++; + } + + public ValueTask BuildAsync(IWorkflowBuilder builder, CancellationToken cancellationToken = default) + { + return ValueTask.CompletedTask; + } + } + + private static void RegisterWorkflowTypeAliases(object feature, SerializationTypeOptions options) + { + feature.GetType() + .GetMethod("RegisterWorkflowTypeAliases", BindingFlags.Instance | BindingFlags.NonPublic)! + .Invoke(feature, new object[] { options }); + } +}