@innovatorstack/harness 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,465 @@
+using System.Runtime.CompilerServices;
+using System.Text.Json;
+using System.Xml;
+
+namespace InnovatorHarness.Managed;
+
+/// <summary>
+/// The managed Item uses a live XML tree. The existing JSON payload is a projection
+/// made at the Bun boundary; XPath and Item helpers therefore see the same nodes.
+/// </summary>
+internal static class ItemXml
+{
+    private static readonly ConditionalWeakTable<XmlElement, ItemData> bindings = new();
+
+    public static XmlElement View(ItemData item)
+    {
+        if (item.Element is not null)
+        {
+            return item.Element;
+        }
+
+        var document = XmlTraversal.Document();
+        XmlElement element = WriteItem(document, item);
+        document.AppendChild(element);
+
+        return element;
+    }
+
+    public static ItemData Bind(XmlElement element)
+    {
+        return bindings.GetValue(element, node => new ItemData { Element = node });
+    }
+
+    public static XmlElement Property(ItemData item, string name)
+    {
+        XmlConvert.VerifyName(name);
+        XmlElement parent = View(item);
+        XmlElement? property = FindProperty(parent, name);
+
+        if (property is null)
+        {
+            property = XmlTraversal.Owner(parent).CreateElement(name);
+            parent.AppendChild(property);
+        }
+
+        return property;
+    }
+
+    public static XmlElement? FindProperty(XmlElement item, string name)
+    {
+        return item.ChildNodes.OfType<XmlElement>().FirstOrDefault(child => child.Name == name);
+    }
+
+    public static void Attach(XmlElement parent, ItemData item)
+    {
+        AttachElement(parent, View(item));
+    }
+
+    public static void Synchronize(ItemPayload payload)
+    {
+        foreach (ItemData item in payload.Items)
+        {
+            ReadItem(item);
+        }
+    }
+
+    private static void Rebind(XmlElement source, XmlElement imported)
+    {
+        foreach (var (original, copied) in XmlTraversal.Pairs(source, imported))
+        {
+            if (bindings.TryGetValue(original, out ItemData? item))
+            {
+                bindings.Remove(original);
+                item.Element = copied;
+                item.SynchronizedRevision = null;
+                bindings.Add(copied, item);
+            }
+        }
+    }
+
+    private sealed record WriteFrame(
+        ItemData Item, XmlElement Element, IEnumerator<Attachment> Children, int Depth);
+    internal sealed record Attachment(XmlElement Parent, ItemData Item);
+
+    private static XmlElement WriteItem(XmlDocument document, ItemData root)
+    {
+        XmlElement element = WriteShell(document, root);
+        var active = new HashSet<ItemData>(ReferenceEqualityComparer.Instance) { root };
+        var pending = new Stack<WriteFrame>();
+        pending.Push(new(root, element, Attachments(root, element).GetEnumerator(), 0));
+        int nodes = 0;
+
+        try
+        {
+            while (pending.Count > 0)
+            {
+                WriteFrame frame = pending.Peek();
+
+                if (!frame.Children.MoveNext())
+                {
+                    pending.Pop().Children.Dispose();
+                    active.Remove(frame.Item);
+                    continue;
+                }
+
+                nodes += 1;
+                Attachment attachment = frame.Children.Current;
+
+                if (active.Contains(attachment.Item) || frame.Depth >= WorkLimits.DepthMax
+                    || nodes > WorkLimits.NodesMax)
+                {
+                    throw new NotSupportedException(
+                        "Item data is cyclic or exceeds its tree budget.");
+                }
+
+                if (attachment.Item.Element is { } existing)
+                {
+                    AttachElement(attachment.Parent, existing);
+                    continue;
+                }
+
+                XmlElement child = WriteShell(document, attachment.Item);
+                attachment.Parent.AppendChild(child);
+                active.Add(attachment.Item);
+                pending.Push(new(attachment.Item, child,
+                    Attachments(attachment.Item, child).GetEnumerator(), frame.Depth + 1));
+            }
+        }
+        finally
+        {
+            foreach (WriteFrame frame in pending)
+            {
+                frame.Children.Dispose();
+            }
+        }
+
+        XmlTraversal.Validate(element);
+
+        return element;
+    }
+
+    private static XmlElement WriteShell(XmlDocument document, ItemData item)
+    {
+        XmlElement element = document.CreateElement("Item");
+        element.SetAttribute("type", item.Type);
+        item.Element = element;
+        bindings.Add(element, item);
+
+        foreach (var attribute in item.Attributes)
+        {
+            element.SetAttribute(attribute.Key, attribute.Value);
+        }
+
+        foreach (var property in item.Properties)
+        {
+            // A projected reference has a scalar ID and an expanded Item in the wire model.
+            // XML represents both through the one property containing that Item.
+            if (item.PropertyItems.ContainsKey(property.Key))
+            {
+                continue;
+            }
+
+            XmlElement child = document.CreateElement(property.Key);
+            WriteAttributes(child, item, property.Key);
+
+            if (property.Value.ValueKind == JsonValueKind.Null)
+            {
+                child.SetAttribute("is_null", "1");
+            }
+            else
+            {
+                child.InnerText = Text(property.Value);
+            }
+
+            element.AppendChild(child);
+        }
+
+        return element;
+    }
+
+    private static IEnumerable<Attachment> Attachments(ItemData item, XmlElement element)
+    {
+        XmlDocument document = XmlTraversal.Owner(element);
+
+        foreach (var property in item.PropertyItems)
+        {
+            XmlElement child = document.CreateElement(property.Key);
+            WriteAttributes(child, item, property.Key);
+            element.AppendChild(child);
+            yield return new(child, property.Value);
+        }
+
+        foreach (var property in item.PropertyAttributes)
+        {
+            string name = property.Key;
+
+            if ((property.Value.Count > 0 || name == "Relationships")
+                && FindProperty(element, name) is null
+                && (name != "Relationships" || item.Relationships.Count == 0))
+            {
+                XmlElement child = document.CreateElement(name);
+                WriteAttributes(child, item, name);
+
+                if (name == "id")
+                {
+                    child.InnerText = item.Attributes.GetValueOrDefault("id", "");
+                }
+
+                element.AppendChild(child);
+            }
+        }
+
+        foreach (Attachment attachment in LogicalXml.Write(item, element))
+        {
+            yield return attachment;
+        }
+
+        if (item.Relationships.Count > 0)
+        {
+            XmlElement relationships = document.CreateElement("Relationships");
+            WriteAttributes(relationships, item, "Relationships");
+            element.AppendChild(relationships);
+
+            foreach (ItemData relationship in item.Relationships)
+            {
+                yield return new(relationships, relationship);
+            }
+        }
+    }
+
+    private static void AttachElement(XmlElement parent, XmlElement element)
+    {
+        if (element.OwnerDocument != parent.OwnerDocument)
+        {
+            XmlTraversal.Validate(element);
+
+            if (XmlTraversal.Owner(parent).ImportNode(element, deep: true)
+                is not XmlElement imported)
+            {
+                throw new InvalidOperationException("An imported XML node must be an element.");
+            }
+
+            Rebind(element, imported);
+            element = imported;
+        }
+
+        parent.AppendChild(element);
+    }
+
+    private static void WriteAttributes(XmlElement element, ItemData item, string name)
+    {
+        if (item.PropertyAttributes.TryGetValue(name, out var attributes))
+        {
+            foreach (var attribute in attributes)
+            {
+                element.SetAttribute(attribute.Key, attribute.Value);
+            }
+        }
+    }
+
+    private static void ReadItem(ItemData root)
+    {
+        if (root.Element is null)
+        {
+            return;
+        }
+
+        var revision = DomChanges.Version(root.Element);
+
+        if (root.SynchronizedRevision == revision)
+        {
+            return;
+        }
+
+        XmlTraversal.Validate(root.Element);
+        var pending = new Stack<(ItemData Item, int Depth)>();
+        var synchronized = new List<ItemData>();
+        pending.Push((root, 0));
+        int nodes = 0;
+
+        while (pending.Count > 0)
+        {
+            var (item, depth) = pending.Pop();
+            nodes += 1;
+
+            if (nodes > WorkLimits.NodesMax || depth > WorkLimits.DepthMax)
+            {
+                throw new NotSupportedException(
+                    "Item data exceeds its transport traversal budget.");
+            }
+
+            foreach (ItemData child in ReadShell(item))
+            {
+                pending.Push((child, depth + 1));
+            }
+
+            synchronized.Add(item);
+        }
+
+        foreach (ItemData item in synchronized)
+        {
+            item.SynchronizedRevision = revision;
+        }
+    }
+
+    private static List<ItemData> ReadShell(ItemData item)
+    {
+        var children = new List<ItemData>();
+        XmlElement element = View(item);
+        var previousValues = new Dictionary<string, JsonElement>(item.Properties);
+        item.Type = element.GetAttribute("type");
+        item.Attributes.Clear();
+        item.Properties.Clear();
+        item.PropertyAttributes.Clear();
+        item.PropertyItems.Clear();
+        item.Relationships.Clear();
+        item.Logical = null;
+
+        foreach (XmlAttribute attribute in element.Attributes)
+        {
+            if (attribute.Name != "type")
+            {
+                item.Attributes.Add(attribute.Name, attribute.Value);
+            }
+        }
+
+        var names = new HashSet<string>();
+
+        if (element.HasAttribute("id"))
+        {
+            names.Add("id");
+        }
+
+        var repeated = new LogicalData { Operator = "and", Terms = new(), Implicit = true };
+
+        foreach (XmlElement property in element.ChildNodes.OfType<XmlElement>())
+        {
+            string name = property.Name;
+
+            if (LogicalXml.IsGroup(name))
+            {
+                (item.Logical ??= new()).Add(LogicalXml.Read(property, children));
+                continue;
+            }
+
+            if (!names.Add(name))
+            {
+                if (name == "Relationships")
+                {
+                    throw new NotSupportedException("Only one Relationships element is allowed.");
+                }
+
+                if (repeated.Terms?.Count == 0)
+                {
+                    (item.Logical ??= new()).Add(repeated);
+                }
+
+                repeated.Terms?.Add(LogicalXml.ReadCondition(property, children));
+                continue;
+            }
+
+            if (name == "Relationships")
+            {
+                item.PropertyAttributes.Add(name, new());
+                ReadRelationships(item, property, children);
+
+                continue;
+            }
+
+            ReadProperty(item, element, property, previousValues, children);
+        }
+
+        return children;
+    }
+
+    private static void ReadRelationships(
+        ItemData item, XmlElement property, List<ItemData> children)
+    {
+        foreach (XmlElement child in property.ChildNodes.OfType<XmlElement>())
+        {
+            if (child.Name != "Item")
+            {
+                throw new NotSupportedException("Relationships must contain Item elements.");
+            }
+
+            ItemData relationship = Bind(child);
+            children.Add(relationship);
+            item.Relationships.Add(relationship);
+        }
+    }
+
+    private static void ReadProperty(
+        ItemData item,
+        XmlElement element,
+        XmlElement property,
+        IReadOnlyDictionary<string, JsonElement> previousValues,
+        List<ItemData> pending)
+    {
+        string name = property.Name;
+
+        if (property.HasAttributes)
+        {
+            item.PropertyAttributes[name] = property.Attributes.Cast<XmlAttribute>()
+                .ToDictionary(attribute => attribute.Name, attribute => attribute.Value);
+        }
+
+        var children = property.ChildNodes.OfType<XmlElement>().ToList();
+
+        if (children.Count > 0)
+        {
+            if (children.Count != 1 || children[0].Name != "Item")
+            {
+                throw new NotSupportedException(
+                    "The managed AML transport requires one Item in nested property "
+                    + $"'{name}'.");
+            }
+
+            ItemData nested = Bind(children[0]);
+            pending.Add(nested);
+            item.PropertyItems.Add(name, nested);
+            string id = children[0].GetAttribute("id");
+
+            if (previousValues.ContainsKey(name) && id.Length > 0)
+            {
+                item.Properties.Add(name, JsonSerializer.SerializeToElement(id));
+            }
+
+            return;
+        }
+
+        if (name == "id" && property.GetAttribute("condition") is "" or "eq")
+        {
+            if (!element.HasAttribute("id"))
+            {
+                item.Attributes["id"] = property.InnerText;
+            }
+
+            return;
+        }
+
+        if (property.GetAttribute("is_null") == "1")
+        {
+            item.Properties[name] = JsonSerializer.SerializeToElement<string?>(null);
+        }
+        else if (previousValues.TryGetValue(name, out JsonElement previous)
+            && previous.ValueKind != JsonValueKind.Null && Text(previous) == property.InnerText)
+        {
+            item.Properties[name] = previous;
+        }
+        else
+        {
+            item.Properties[name] = JsonSerializer.SerializeToElement(property.InnerText);
+        }
+    }
+
+    private static string Text(JsonElement value)
+    {
+        if (value.ValueKind == JsonValueKind.String)
+        {
+            return value.GetString() ?? "";
+        }
+
+        return value.GetRawText();
+    }
+}

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

@@ -0,0 +1,20 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace InnovatorHarness.Managed;
+
+public sealed class LogicalData
+{
+    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
+    public string? Operator { get; set; }
+    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
+    public List<LogicalData>? Terms { get; set; }
+    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
+    public string? Name { get; set; }
+    public Dictionary<string, string> Attributes { get; set; } = new();
+    public JsonElement Value { get; set; } = JsonSerializer.SerializeToElement<string?>(null);
+    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
+    public ItemData? Item { get; set; }
+    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingDefault)]
+    public bool Implicit { get; set; }
+}

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

@@ -0,0 +1,181 @@
+using System.Text.Json;
+using System.Xml;
+
+namespace InnovatorHarness.Managed;
+
+internal static class LogicalXml
+{
+    public static bool IsGroup(string name) => name is "and" or "or" or "not";
+
+    public static LogicalData Read(XmlElement root, List<ItemData> children)
+    {
+        var result = new LogicalData { Operator = root.Name, Terms = new() };
+        var pending = new Stack<(XmlElement Element, LogicalData Group)>();
+        pending.Push((root, result));
+
+        while (pending.Count > 0)
+        {
+            var (element, group) = pending.Pop();
+
+            if (element.HasAttributes || element.ChildNodes.OfType<XmlText>()
+                .Any(text => !string.IsNullOrWhiteSpace(text.Value)))
+            {
+                throw new NotSupportedException("Logical groups require property criteria.");
+            }
+
+            List<LogicalData> terms = group.Terms
+                ?? throw new InvalidOperationException("A logical group must retain its terms.");
+
+            foreach (XmlElement property in element.ChildNodes.OfType<XmlElement>())
+            {
+                if (IsGroup(property.Name))
+                {
+                    var nested = new LogicalData { Operator = property.Name, Terms = new() };
+                    terms.Add(nested);
+                    pending.Push((property, nested));
+                }
+                else
+                {
+                    terms.Add(ReadCondition(property, children));
+                }
+            }
+        }
+
+        return result;
+    }
+
+    public static LogicalData ReadCondition(XmlElement property, List<ItemData> children)
+    {
+        var condition = new LogicalData
+        {
+            Name = property.Name,
+            Attributes = property.Attributes.Cast<XmlAttribute>()
+                .ToDictionary(attribute => attribute.Name, attribute => attribute.Value)
+        };
+        var nested = property.ChildNodes.OfType<XmlElement>().ToList();
+
+        if (nested.Count > 0)
+        {
+            if (nested.Count != 1 || nested[0].Name != "Item")
+            {
+                throw new NotSupportedException("A property must contain one nested Item.");
+            }
+
+            condition.Item = ItemXml.Bind(nested[0]);
+            children.Add(condition.Item);
+        }
+        else
+        {
+            string? value = property.InnerText;
+
+            if (property.GetAttribute("is_null") == "1")
+            {
+                value = null;
+            }
+
+            condition.Value = JsonSerializer.SerializeToElement(value);
+        }
+
+        return condition;
+    }
+
+    public static IEnumerable<ItemXml.Attachment> Write(ItemData item, XmlElement element)
+    {
+        var pending = new Stack<(LogicalData Data, XmlElement Parent, int Depth)>();
+
+        foreach (LogicalData group in (item.Logical ?? new()).AsEnumerable().Reverse())
+        {
+            pending.Push((group, element, 0));
+        }
+
+        int visited = 0;
+
+        while (pending.Count > 0)
+        {
+            var (data, parent, depth) = pending.Pop();
+            visited += 1;
+
+            if (visited > WorkLimits.NodesMax || depth > WorkLimits.DepthMax)
+            {
+                throw new NotSupportedException("Logical AML exceeds its traversal budget.");
+            }
+
+            if (data.Operator is not null)
+            {
+                XmlElement container = GroupElement(data, parent, depth);
+
+                List<LogicalData> terms = data.Terms
+                    ?? throw new InvalidOperationException("A logical group needs terms.");
+
+                for (int index = terms.Count - 1; index >= 0; index -= 1)
+                {
+                    pending.Push((terms[index], container, depth + 1));
+                }
+
+            }
+            else
+            {
+                XmlElement property = WriteCondition(data, parent);
+
+                if (data.Item is not null)
+                {
+                    yield return new(property, data.Item);
+                }
+            }
+        }
+    }
+
+    private static XmlElement GroupElement(LogicalData data, XmlElement parent, int depth)
+    {
+        if (!IsGroup(data.Operator ?? "")
+            || (data.Implicit && (data.Operator != "and" || depth != 0)))
+        {
+            throw new NotSupportedException("Invalid logical AML operator or implicit group.");
+        }
+
+        if (data.Implicit)
+        {
+            return parent;
+        }
+
+        XmlElement group = XmlTraversal.Owner(parent).CreateElement(data.Operator
+            ?? throw new InvalidOperationException("A logical group needs its operator."));
+        parent.AppendChild(group);
+
+        return group;
+    }
+
+    private static XmlElement WriteCondition(LogicalData data, XmlElement parent)
+    {
+        XmlElement property = XmlTraversal.Owner(parent).CreateElement(data.Name
+            ?? throw new InvalidOperationException("A criterion needs a property name."));
+
+        foreach (var attribute in data.Attributes)
+        {
+            property.SetAttribute(attribute.Key, attribute.Value);
+        }
+
+        if (data.Item is null)
+        {
+            if (data.Value.ValueKind == JsonValueKind.Null)
+            {
+                property.SetAttribute("is_null", "1");
+            }
+            else
+            {
+                string text = data.Value.GetRawText();
+
+                if (data.Value.ValueKind == JsonValueKind.String)
+                {
+                    text = data.Value.GetString() ?? "";
+                }
+
+                property.InnerText = text;
+            }
+        }
+
+        parent.AppendChild(property);
+
+        return property;
+    }
+}

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

@@ -0,0 +1,48 @@
+using System.Xml;
+
+namespace InnovatorHarness.Managed;
+
+internal static class ManagedDocuments
+{
+    internal static XmlDocument Read(DocumentInput input)
+    {
+        XmlDocument document = XmlTraversal.Load(input.Xml);
+
+        if (input.Change is { } change)
+        {
+            RequestXml.Synchronize(RequestXml.Input(document), change);
+        }
+
+        return document;
+    }
+
+    internal static ItemPayload Restore(ItemPayload expected, DocumentInput input)
+    {
+        XmlDocument document = Read(input);
+        ItemPayload payload = ResponseXml.Read(document);
+        ItemXml.Synchronize(payload);
+        using var originals = RequestOrigins.Nodes(expected).GetEnumerator();
+
+        foreach (ItemData item in RequestOrigins.Nodes(payload))
+        {
+            if (!originals.MoveNext())
+            {
+                throw new InvalidOperationException("Reloaded document has extra Items.");
+            }
+
+            // Preserve typed JSON values when their XML text still matches.
+            item.Properties = new(originals.Current.Properties);
+            item.SynchronizedRevision = null;
+        }
+
+        if (originals.MoveNext())
+        {
+            throw new InvalidOperationException("Reloaded document is missing Items.");
+        }
+
+        ItemXml.Synchronize(payload);
+        ItemDocuments.Remember(payload, document);
+
+        return payload;
+    }
+}