@innovatorstack/harness 0.0.0-stage → 0.1.0

package/dist/methods/csharp/managed/RequestXml.cs

@@ -0,0 +1,237 @@
+using System.Xml;
+
+namespace InnovatorHarness.Managed;
+
+/// <summary>Apply native request changes without replacing retained input DOM nodes.</summary>
+internal static class RequestXml
+{
+    internal sealed record Frame(
+        XmlElement Target, XmlElement Before, XmlElement After, int Depth,
+        RequestAlignment? Alignment);
+    private readonly record struct ChildKey(string Name, int Occurrence);
+
+    public static void Synchronize(XmlElement target, RequestChange change)
+    {
+        XmlElement before = ItemXml.View(change.Before);
+        XmlElement after = ItemXml.View(change.After);
+        XmlTraversal.Validate(target);
+        XmlTraversal.Validate(before);
+        XmlTraversal.Validate(after);
+        var pending = new Stack<Frame>();
+        pending.Push(new(target, before, after, 0, change.Alignment));
+        int visited = 0;
+
+        while (pending.Count > 0)
+        {
+            Frame frame = pending.Pop();
+            visited += 1;
+
+            if (visited > WorkLimits.NodesMax || frame.Depth > WorkLimits.DepthMax
+                || pending.Count > WorkLimits.NodesMax)
+            {
+                throw new NotSupportedException("Request synchronization exceeds its budget.");
+            }
+
+            if (frame.Target.Name != frame.Before.Name || frame.Before.Name != frame.After.Name)
+            {
+                throw new InvalidOperationException("A native request must retain its root shape.");
+            }
+
+            Attributes(frame);
+            Children(frame, pending);
+        }
+
+        XmlTraversal.Validate(target);
+    }
+
+    public static XmlElement Input(XmlDocument document)
+    {
+        ItemPayload request = ResponseXml.Read(document);
+
+        if (request.Items.Count != 1 || request.Error is not null || request.Result is not null)
+        {
+            throw new InvalidOperationException("A native base call requires one input Item.");
+        }
+
+        return ItemXml.View(request.Items[0]);
+    }
+
+    private static void Attributes(Frame frame)
+    {
+        var before = AttributeMap(frame.Before);
+        var after = AttributeMap(frame.After);
+        var targets = AttributeMap(frame.Target);
+
+        foreach (var (name, _) in before)
+        {
+            if (!after.ContainsKey(name) && targets.TryGetValue(name, out XmlAttribute? target))
+            {
+                frame.Target.Attributes.Remove(target);
+            }
+        }
+
+        foreach (var (name, attribute) in after)
+        {
+            if (before.TryGetValue(name, out XmlAttribute? previous)
+                && previous.Value == attribute.Value)
+            {
+                continue;
+            }
+
+            if (targets.TryGetValue(name, out XmlAttribute? target))
+            {
+                target.Value = attribute.Value;
+            }
+            else
+            {
+                XmlNode copied = XmlTraversal.Owner(frame.Target).ImportNode(attribute, true);
+                frame.Target.Attributes.SetNamedItem(copied);
+            }
+        }
+    }
+
+    private static Dictionary<string, XmlAttribute> AttributeMap(XmlElement element)
+    {
+        return element.Attributes.OfType<XmlAttribute>()
+            .ToDictionary(attribute => attribute.Name, StringComparer.Ordinal);
+    }
+
+    private static void Children(Frame frame, Stack<Frame> pending)
+    {
+        if (frame.Alignment?.ReplaceItem == true)
+        {
+            ReplacePropertyItem(frame);
+
+            return;
+        }
+
+        if (frame.Before.Name == "Relationships" && frame.Alignment?.Relationships is { } order)
+        {
+            RequestRelationships.Synchronize(frame, pending, order);
+
+            return;
+        }
+
+        var before = Elements(frame.Before);
+        var after = Elements(frame.After);
+
+        if (before.Count == 0 && after.Count == 0)
+        {
+            Text(frame);
+
+            return;
+        }
+
+        if ((before.Count == 0 || after.Count == 0) && !IsCollection(frame.Before))
+        {
+            ReplaceContent(frame.Target, frame.After);
+
+            return;
+        }
+
+        var targets = Elements(frame.Target);
+
+        foreach (var (key, previous) in before)
+        {
+            if (!targets.TryGetValue(key, out XmlElement? target))
+            {
+                throw new InvalidOperationException(
+                    "The input request changed during its base call.");
+            }
+
+            if (after.TryGetValue(key, out XmlElement? next))
+            {
+                var alignment = frame.Alignment;
+
+                if (frame.Before.Name == "Item" && key.Name != "Relationships"
+                    && key.Occurrence == 0)
+                {
+                    alignment = frame.Alignment?.Properties?.GetValueOrDefault(key.Name);
+                }
+
+                pending.Push(new(target, previous, next, frame.Depth + 1, alignment));
+            }
+            else
+            {
+                frame.Target.RemoveChild(target);
+            }
+        }
+
+        foreach (var (key, next) in after)
+        {
+            if (!before.ContainsKey(key))
+            {
+                frame.Target.AppendChild(XmlTraversal.Owner(frame.Target).ImportNode(next, true));
+            }
+        }
+    }
+
+    private static void ReplacePropertyItem(Frame frame)
+    {
+        var before = frame.Before.ChildNodes.OfType<XmlElement>().ToArray();
+        var after = frame.After.ChildNodes.OfType<XmlElement>().ToArray();
+        var targets = frame.Target.ChildNodes.OfType<XmlElement>().ToArray();
+
+        if (frame.Depth == 0 || before.Length != 1 || after.Length != 1
+            || targets.Length != 1 || before[0].Name != "Item" || after[0].Name != "Item"
+            || targets[0].Name != "Item")
+        {
+            throw new InvalidOperationException(
+                "A property Item replacement requires one original and resulting child.");
+        }
+
+        PropertyItems.Replace(frame.Target, after[0]);
+    }
+
+    private static bool IsCollection(XmlElement element)
+    {
+        return element.Name == "Relationships" || LogicalXml.IsGroup(element.Name)
+            || (element.Name == "Item" && element.HasAttribute("type"));
+    }
+
+    private static Dictionary<ChildKey, XmlElement> Elements(XmlElement element)
+    {
+        var elements = new Dictionary<ChildKey, XmlElement>();
+        var counts = new Dictionary<string, int>();
+
+        foreach (XmlElement child in element.ChildNodes.OfType<XmlElement>())
+        {
+            int occurrence = counts.GetValueOrDefault(child.Name);
+            counts[child.Name] = occurrence + 1;
+            elements.Add(new(child.Name, occurrence), child);
+        }
+
+        return elements;
+    }
+
+    private static void Text(Frame frame)
+    {
+        if (frame.Before.InnerText == frame.After.InnerText)
+        {
+            return;
+        }
+
+        if (frame.Target.ChildNodes.Count == 1
+            && frame.Target.FirstChild is XmlCharacterData text)
+        {
+            text.Value = frame.After.InnerText;
+        }
+        else
+        {
+            frame.Target.InnerText = frame.After.InnerText;
+        }
+    }
+
+    private static void ReplaceContent(XmlElement target, XmlElement source)
+    {
+        while (target.FirstChild is { } child)
+        {
+            target.RemoveChild(child);
+        }
+
+        foreach (XmlNode child in source.ChildNodes)
+        {
+            target.AppendChild(XmlTraversal.Owner(target).ImportNode(child, true));
+        }
+    }
+}

package/dist/methods/csharp/managed/ResponseXml.cs

@@ -0,0 +1,114 @@
+using System.Xml;
+
+namespace InnovatorHarness.Managed;
+
+internal static class ResponseXml
+{
+    public static ItemPayload Read(XmlDocument document)
+    {
+        XmlElement root = XmlTraversal.Root(document);
+        XmlTraversal.Validate(root);
+
+        if (root.Name is "Item" or "Result" or "AML")
+        {
+            return ReadResult(root);
+        }
+
+        if (root.LocalName != "Envelope"
+            || root.NamespaceURI != "http://schemas.xmlsoap.org/soap/envelope/")
+        {
+            throw new NotSupportedException("Expected a native AML response or SOAP envelope.");
+        }
+
+        XmlElement body = root.ChildNodes.OfType<XmlElement>()
+            .Single(element => element.LocalName == "Body"
+                && element.NamespaceURI == root.NamespaceURI);
+        XmlElement? fault = body.ChildNodes.OfType<XmlElement>()
+            .SingleOrDefault(element => element.LocalName == "Fault");
+
+        if (fault is not null)
+        {
+            return new ItemPayload
+            {
+                Error = new(
+                fault.SelectSingleNode("faultcode")?.InnerText ?? "ApplicationError",
+                fault.SelectSingleNode("faultstring")?.InnerText
+                    ?? "Native Method returned a fault.")
+            };
+        }
+
+        XmlElement result = body.ChildNodes.OfType<XmlElement>()
+            .Single(element => element.Name == "Result");
+        var payload = ReadResult(result);
+        XmlNodeList messages = body.SelectNodes("Message/event")
+            ?? throw new InvalidOperationException("Response messages must be readable.");
+
+        if (messages.Count > 0)
+        {
+            payload.Messages = messages.OfType<XmlElement>()
+                .Select(element => new ItemMessage(
+                    element.GetAttribute("name"), element.GetAttribute("value")))
+                .ToList();
+        }
+
+        return payload;
+    }
+
+    public static void Write(XmlDocument document, ItemPayload payload)
+    {
+        document.RemoveAll();
+        XmlElement result = PayloadXml.CreateResult(document, payload, wrapEnvelope: true);
+
+        if (payload.Error is { } error)
+        {
+            XmlElement fault = document.CreateElement(
+                "SOAP-ENV", "Fault", "http://schemas.xmlsoap.org/soap/envelope/");
+            XmlElement code = document.CreateElement("faultcode");
+            XmlElement message = document.CreateElement("faultstring");
+            code.InnerText = error.Code;
+            message.InnerText = error.Message;
+            fault.AppendChild(code);
+            fault.AppendChild(message);
+            result.ParentNode?.ReplaceChild(fault, result);
+
+            return;
+        }
+
+        if (payload.Result is not null)
+        {
+            result.InnerText = payload.Result;
+        }
+
+        foreach (ItemData item in payload.Items)
+        {
+            ItemXml.Attach(result, item);
+        }
+    }
+
+    private static ItemPayload ReadResult(XmlElement result)
+    {
+        if (result.Name == "Item")
+        {
+            return new ItemPayload { Items = new() { ItemXml.Bind(result) } };
+        }
+
+        var items = new List<ItemData>();
+
+        foreach (XmlElement element in result.ChildNodes.OfType<XmlElement>())
+        {
+            if (element.Name != "Item")
+            {
+                throw new NotSupportedException("A native Result must contain Item elements.");
+            }
+
+            items.Add(ItemXml.Bind(element));
+        }
+
+        if (items.Count == 0 && result.Name == "Result")
+        {
+            return new ItemPayload { Result = result.InnerText };
+        }
+
+        return new ItemPayload { Items = items };
+    }
+}

package/dist/methods/csharp/managed/ServerEventArgs.cs

@@ -0,0 +1,223 @@
+using System.Xml;
+using InnovatorHarness.Managed;
+
+namespace Aras.Server.Core;
+
+public class ServerEventArgs
+{
+    private readonly Remote remote;
+    private readonly XmlDocument? input;
+    private readonly XmlElement? originalRoot;
+    private readonly XmlElement? originalRequest;
+
+    public ServerEventArgs(Remote remote, XmlDocument? input = null)
+    {
+        this.remote = remote;
+        this.input = input;
+
+        if (input is not null)
+        {
+            originalRoot = input.DocumentElement;
+            originalRequest = SingleRequest(input);
+        }
+    }
+
+    private static XmlElement? SingleRequest(XmlDocument document)
+    {
+        if (document.DocumentElement is { Name: "Item" } root)
+        {
+            return root;
+        }
+
+        XmlNodeList? selected = document.SelectNodes("Item|AML/Item|//Result/Item");
+
+        if (selected is { Count: 1 } && selected[0] is XmlElement item)
+        {
+            return item;
+        }
+
+        return null;
+    }
+
+    protected void ApplyBase(string name, XmlDocument output)
+    {
+        var document = input
+            ?? throw new InvalidOperationException("A base delegate requires its event context.");
+        XmlElement request;
+
+        if (name is "onGet" or "onUpdate")
+        {
+            request = CapturedInput(document);
+        }
+        else
+        {
+            request = RequestXml.Input(document);
+        }
+
+        XmlElement? currentRequest = SingleRequest(document);
+        object arguments = CallbackInput(name, document, request);
+        var payload = remote.Call("eventBase", arguments,
+            change => Synchronize(document, request, currentRequest, change));
+        ResponseXml.Write(output, payload);
+    }
+
+    private object CallbackInput(string name, XmlDocument document, XmlElement request)
+    {
+        var context = new ItemPayload { Items = new() { ItemXml.Bind(request) } };
+        var origins = remote.Origins.Capture(context);
+        bool detached = !IsAttached(request, document);
+        bool wrapped = !detached && !ReferenceEquals(request, document.DocumentElement);
+        string xml = request.OuterXml;
+        string? currentDocument = null;
+        OriginFrame? currentOrigins = null;
+
+        if (wrapped)
+        {
+            xml = document.OuterXml;
+        }
+
+        if (detached)
+        {
+            currentDocument = document.OuterXml;
+            currentOrigins = remote.Origins.Capture(ResponseXml.Read(document));
+        }
+
+        return new { name, xml, origins, document = wrapped, currentDocument, currentOrigins };
+    }
+
+    private XmlElement CapturedInput(XmlDocument document)
+    {
+        if (originalRequest is null)
+        {
+            remote.Unsupported("A native base action requires one captured request Item.");
+
+            throw new InvalidOperationException("Missing captured base request.");
+        }
+
+        if (!ReferenceEquals(originalRoot, document.DocumentElement)
+            && IsAttached(originalRequest, document))
+        {
+            remote.Unsupported("Moving a retained base request into another XML container "
+                + "requires a qualified XML mapping.");
+        }
+
+        return originalRequest;
+    }
+
+    private static bool IsAttached(XmlElement request, XmlDocument document)
+    {
+        XmlNode? current = request;
+
+        for (int depth = 0; current is not null && depth <= WorkLimits.DepthMax; depth++)
+        {
+            if (ReferenceEquals(current, document))
+            {
+                return true;
+            }
+
+            current = current.ParentNode;
+        }
+
+        if (current is not null)
+        {
+            throw new NotSupportedException("A base request exceeds its ancestry limit.");
+        }
+
+        return false;
+    }
+
+    private void Synchronize(
+        XmlDocument document, XmlElement request,
+        XmlElement? currentRequest, BaseInputChange change)
+    {
+        try
+        {
+            if (change.Request is { } patch)
+            {
+                RequestXml.Synchronize(request, patch);
+            }
+
+            remote.Origins.Apply(new ItemPayload { Items = new() { ItemXml.Bind(request) } },
+                change.Origins);
+
+            if (change.RetainedDocument is { } retained)
+            {
+                if (currentRequest is null || ReferenceEquals(currentRequest, request))
+                {
+                    throw new InvalidOperationException(
+                        "Missing separately retained document Item.");
+                }
+
+                RequestXml.Synchronize(currentRequest, retained);
+                remote.Origins.Apply(
+                    new ItemPayload { Items = new() { ItemXml.Bind(currentRequest) } },
+                    change.RetainedOrigins);
+            }
+
+            if (change.Document is { } input)
+            {
+                XmlDocument current = ManagedDocuments.Read(input);
+                document.RemoveAll();
+
+                foreach (XmlNode node in current.ChildNodes)
+                {
+                    document.AppendChild(document.ImportNode(node, deep: true));
+                }
+
+                remote.Origins.Apply(ResponseXml.Read(document), change.DocumentOrigins);
+            }
+            else if (change.DocumentChange is { } documentChange)
+            {
+                RequestXml.Synchronize(RequestXml.Input(document), documentChange);
+                remote.Origins.Apply(ResponseXml.Read(document), change.DocumentOrigins);
+            }
+        }
+        catch (Exception exception)
+            when (exception is NotSupportedException or InvalidOperationException)
+        {
+            remote.Unsupported(exception.Message);
+        }
+    }
+}
+
+public sealed class OnGetEventArgs(Remote remote, XmlDocument input)
+    : ServerEventArgs(remote, input)
+{
+    public void BaseGetItem(XmlDocument output) => ApplyBase("onGet", output);
+}
+
+public sealed class OnAddEventArgs(Remote remote, XmlDocument input)
+    : ServerEventArgs(remote, input)
+{
+    public void BaseAddItem(XmlDocument output) => ApplyBase("onAdd", output);
+}
+
+public sealed class OnUpdateEventArgs(Remote remote, XmlDocument input)
+    : ServerEventArgs(remote, input)
+{
+    public void BaseUpdateItem(XmlDocument output) => ApplyBase("onUpdate", output);
+}
+
+public sealed class OnDeleteEventArgs(Remote remote, XmlDocument input)
+    : ServerEventArgs(remote, input)
+{
+    public void BaseDeleteItem(XmlDocument output) => ApplyBase("onDelete", output);
+}
+
+public sealed class OnLockEventArgs(Remote remote, XmlDocument input)
+    : ServerEventArgs(remote, input)
+{
+    public void BaseLockItem(XmlDocument output) => ApplyBase("onLock", output);
+}
+
+public sealed class OnUnlockEventArgs(Remote remote, XmlDocument input)
+    : ServerEventArgs(remote, input)
+{
+    public void BaseUnlockItem(XmlDocument output) => ApplyBase("onUnlock", output);
+}
+
+public sealed class OnPromoteEventArgs(Remote remote, XmlDocument input)
+    : ServerEventArgs(remote, input)
+{
+    public void BasePromoteItem(XmlDocument output) => ApplyBase("onPromote", output);
+}

package/dist/methods/csharp/managed/WorkLimits.cs

@@ -0,0 +1,11 @@
+namespace InnovatorHarness.Managed;
+
+internal static class WorkLimits
+{
+    // Match the transport/data budgets in the Bun owner. Contract tests check these values.
+    public const int DepthMax = 256;
+    public const int NodesMax = 1_000_000;
+    public const int DataBytesMax = 64 * 1024 * 1024;
+    public const int MessageBytesMax = 8 * 1024 * 1024;
+    public const int PendingCallsMax = 128;
+}

package/dist/methods/csharp/managed/Worker.csproj

@@ -0,0 +1,23 @@
+<Project Sdk="Microsoft.NET.Sdk">
+    <PropertyGroup>
+        <OutputType>Exe</OutputType>
+        <TargetFramework>net10.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+        <AssemblyName>InnovatorHarness.Managed</AssemblyName>
+        <ProduceReferenceAssembly>true</ProduceReferenceAssembly>
+        <ProduceReferenceAssemblyInOutDir>true</ProduceReferenceAssemblyInOutDir>
+        <Optimize>true</Optimize>
+        <RestoreIgnoreFailedSources>true</RestoreIgnoreFailedSources>
+    </PropertyGroup>
+    <ItemGroup>
+        <PackageReference Include="Newtonsoft.Json" Version="13.0.4" />
+    </ItemGroup>
+    <Target Name="HarnessCompilerInputs" AfterTargets="Build">
+        <WriteLinesToFile File="$(TargetDir)compiler-inputs.txt"
+            Lines="$(MSBuildToolsPath)/Roslyn/bincore/csc.dll;@(ReferencePath->'%(FullPath)')"
+            Overwrite="true" />
+        <WriteLinesToFile File="$(TargetDir)compiler-symbols.txt"
+            Lines="$(DefineConstants)" Overwrite="true" />
+    </Target>
+</Project>

package/dist/methods/csharp/managed/XmlProperties.cs

@@ -0,0 +1,32 @@
+using System.Xml;
+
+namespace Aras.Server.Core;
+
+public static class XML
+{
+    public static void SetItemPropertyNullInternal(XmlElement item, string name, bool setNullFlag)
+    {
+        XmlConvert.VerifyName(name);
+        var document = item.OwnerDocument
+            ?? throw new InvalidOperationException("An Item element requires its owner document.");
+        XmlElement? property = item.ChildNodes.OfType<XmlElement>()
+            .FirstOrDefault(element => element.Name == name);
+
+        if (property is null)
+        {
+            property = document.CreateElement(name);
+            item.AppendChild(property);
+        }
+
+        property.InnerText = string.Empty;
+
+        if (setNullFlag)
+        {
+            property.SetAttribute("is_null", "1");
+        }
+        else
+        {
+            property.SetAttribute("is_null", "0");
+        }
+    }
+}