Stop attaching Array.prototype to dictionary-like objects in JavaScript expressions

[lahma]

Problem

JintJavaScriptEvaluator installs a custom WrapObjectDelegate:

options.SetWrapObjectHandler((engine, target, type) =>
{
    var instance = ObjectWrapper.Create(engine, target);

    if (ObjectArrayHelper.DetermineIfObjectIsArrayLikeClrCollection(target.GetType()))
        instance.Prototype = engine.Intrinsics.Array.PrototypeObject;

    return instance;
});

This duplicates what Jint already does, and gets it wrong in two ways.

Jint's default handler is ObjectWrapper.Create(engine, target, type), and ObjectWrapper attaches Array.prototype to array-like wrappers by itself whenever Options.Interop.AttachArrayPrototype is enabled — which it is by default. Jint's own array-likeness test deliberately treats dictionary-like types, including string-keyed generic dictionaries, as plain objects.

The handler above:

• drops the declared type argument, so wrapper members are resolved against the runtime type rather than the declared one;
• delegates the array-likeness decision to ObjectArrayHelper.DetermineIfObjectIsArrayLikeClrCollection, which only excludes the non-generic IDictionary. ExpandoObject does not implement that interface — it implements IDictionary<string, object> and ICollection<KeyValuePair<string, object>> — so it comes out array-like.

Both the variables container (ConfigureEngineWithVariables) and the args container (JavaScriptExpressionHandler) are ExpandoObject instances. The observable result today:

Object.getPrototypeOf(variables) === Array.prototype   // true
typeof variables.map                                   // "function"
typeof variables.filter                                // "function"
variables.length                                       // 0, rather than undefined

Fix

Remove the handler. Jint's default covers every case the custom one was written for — verified against a plain engine:

wrapped value	gets Array.prototype
string[], List<T>, HashSet<T>, ImmutableArray<T>, ImmutableList<T>, Queue<T>, Stack<T>	yes
Dictionary<string, object>, ExpandoObject, a bare IEnumerable<T> iterator	no

ObjectArrayHelper is public, so it is marked [Obsolete] rather than deleted.

Tests

New ObjectWrappingTests covers both directions: the variables container and dictionary-like objects are plain objects, and array-like CLR collections still expose Array.prototype and still support map/reduce where the collection is indexable.

Elsa.JavaScript.IntegrationTests 73 → 80 passing, Elsa.Workflows.IntegrationTests 270 passing, both before and after.

Note for reviewers: HashSet<T> gets Array.prototype but has no integer indexer, so set.map(...) yields empty entries. That is unchanged by this PR — it behaves identically with and without the custom handler — so the test asserts prototype presence for sets and functional iteration only for indexable collections.

🤖 Generated with Claude Code

https://claude.ai/code/session_0179sA2T7HuRfRfSc2JirFik

[greptile-apps]

PR author is not in the allowed authors list.

[Copilot]

Pull request overview

This PR corrects how CLR objects are wrapped/exposed inside Elsa’s Jint-based JavaScript evaluator by removing a custom WrapObjectDelegate that incorrectly attached Array.prototype to dictionary-like objects (e.g., ExpandoObject-backed variables/args), and by adding integration coverage to prevent regressions.

Changes:

• Removed the custom Jint object-wrap handler so Jint’s built-in array-likeness logic governs whether Array.prototype is attached.
• Marked ObjectArrayHelper as [Obsolete] since the evaluator no longer uses it.
• Added integration tests asserting dictionary-like objects remain plain objects while array-like CLR collections still get array prototype behavior.

Reviewed changes

Copilot reviewed 3 out of 3 changed files in this pull request and generated 1 comment.

File	Description
test/integration/Elsa.JavaScript.IntegrationTests/ObjectWrappingTests.cs	Adds integration tests validating prototype behavior for variables, dictionary-like objects, and array-like CLR collections.
src/modules/Elsa.Expressions.JavaScript/Services/JintJavaScriptEvaluator.cs	Removes the custom wrap-object handler to rely on Jint’s default object wrapping behavior.
src/modules/Elsa.Expressions.JavaScript/Helpers/ObjectArrayHelper.cs	Marks the helper obsolete now that array-likeness decisions are delegated to Jint.

[Copilot]

Pull request overview

Copilot reviewed 3 out of 3 changed files in this pull request and generated no new comments.

[lahma]

Rebased onto current main (bd903f6). No changes beyond the rebase; Elsa.JavaScript.IntegrationTests green (80 passing).

[sfmskywalker]

Thanks @lahma!