DevScope Integration Toolkit

By DevScope · www.devscope.net | info@devscope.net | +351 22 375 1350

Visual tools for Azure Integration Services and BizTalk work, inside VS Code:

Data Mapper: map a source schema to a target schema on a visual canvas and export XSLT for BizTalk, Azure Logic Apps or standard XSLT 1.0.
Visual XSD Editor: build and edit XML Schemas (.xsd) as a tree, in the style of the BizTalk Schema Editor, or generate them from an XML message; several schemas that import and reference each other can be edited and saved together.
Visual JSON Schema Editor: build and edit JSON Schemas (.json) as a tree, with a live preview and a sample instance, or generate one from a JSON message.
Flat File Wizard: from a CSV, delimited or fixed-width sample, create a BizTalk / Logic Apps flat file schema (.xsd), or convert the sample to JSON with a JSON Schema.
Schema Validator: validate an XML document against an XSD, or a JSON document against a JSON Schema, with plain-English explanations and suggested fixes; problems also appear in VS Code's Problems panel, underlined in the file.
Workflow Diff: compare two Azure Logic Apps (or Power Automate) workflow definitions and see on a drawing of the flow which triggers and actions were added, removed or modified, with the field-by-field difference of each.
XPath Tester: run XPath 1.0 expressions against an XML message, see the matches highlighted in a tree, and get the XPath of any node (with prefixes, or BizTalk-style local-name()).
Logic Apps JSON Path Tester: click any value of a JSON payload (or of its JSON Schema) to get the Logic Apps expression that reads it (triggerBody(), body('Action'), items('For_each') / item() inside a For each), test expressions against the payload, and generate the schema for a Parse JSON action.
Schema to C#: generate C# classes from JSON Schemas (System.Text.Json or Newtonsoft.Json) or from XSD schemas (XmlSerializer classes, like xsd.exe /classes), with references between several schema files.

The editors work on files: a map is a .json file, an XML Schema is an .xsd file and a JSON Schema is a .json file. They open as editors in their own tabs and follow VS Code's usual behaviour: ● for unsaved changes, Ctrl+S, Undo/Redo, Auto Save, Git. They use VS Code's colours, fonts and icons, including Dark, Light and High Contrast themes.

Everything runs locally. Schemas, maps and messages never leave your machine.

Getting started

Install the extension (Extensions view → … → Install from VSIX…).
Click the DevScope Integration Toolkit icon in the Activity Bar.
The sidebar has three sections, by what the tools are for:
- Edit: Data Mapper, Visual XSD Editor, Visual JSON Schema Editor. Click one to choose New or Open…, or use the New (+) and Open (folder) buttons that appear on the row when you point at it;
- Generate: Flat File Wizard, Schema to C#;
- Test & Compare: Schema Validator, XPath Tester, Logic Apps JSON Path, Workflow Diff.
Click a tool to open it; point at it for a short explanation. Each section can be folded, resized or hidden like any VS Code sidebar section; the Edit section's header has Settings (⚙).

You can also right-click a file or folder in the Explorer (or a file's tab) → DevScope Integration Toolkit. Only the options that fit what you clicked are shown:

a .json: Open in Data Mapper (a map), Open in Visual JSON Schema Editor (a JSON Schema), Generate JSON Schema… (from a JSON message), Generate C# Classes… (from a JSON Schema; also with several .json files selected), Build Logic Apps Expressions… (a JSON payload or its JSON Schema);
an .xsd: Open in Visual XSD Editor, Generate C# Classes… (also with several .xsd files selected); an .xml: Generate XSD Schema… (from an XML message) and Test XPath…;
a .csv / .txt / .dat / .prn / .tsv: Open in Flat File Wizard;
an .xml / .xsd / .json: Schema Validator › Validate Document…, Validate a Document Against This Schema…;
two .json files selected: Compare Logic App Workflows;
a folder: New › New Map…, New XSD Schema…, New JSON Schema… (the file is created in that folder and opened).

Opening schemas and workflows. The buttons that open a schema list the schemas of your Logic Apps project first: every .xsd (or JSON Schema .json) in an Artifacts/Schemas folder of the open folders, subfolders included, with Browse… below for a file anywhere else. This is how the Schema Validator's schema box (Open File…), Schema to C#'s Open Files… (tick several), the Visual XSD Editor's + Add Schema File… and Imports › Open XSD File…, the editors' Open… (sidebar) and Replace with … File… work. Workflow Diff's Open File… lists every workflow folder (a folder with a workflow.json) by name, then Browse…. Nothing is copied: the file is used where it is (the XSD editor still copies files from outside the project's Artifacts/Schemas next to the open schema, see below). With no folder open, these buttons show VS Code's Open dialog directly.

Data Mapper

Building a map

Schemas: load the source and target from an XSD or from a sample XML message (the structure is inferred from the sample). Load Schema… (the folder icon in the Source Schema / Target Schema panel header, or the button in an empty panel) opens a list at the top of VS Code with the .xsd / .xml files in the workspace's Artifacts/Schemas folder (the Logic Apps project layout; subfolders included). Type to filter, pick one, and it's loaded. Below the list: Browse… copies a schema file from anywhere into Artifacts/Schemas (creating the folder if needed) and loads it from there; a file that is already in the folder is just loaded, and if a different file with the same name is there you choose Replace or Use the Existing One. Paste Schema Text… opens a box to paste an XSD or sample XML. (With no folder open, Browse… loads the file without copying it.) If the schema is open in VS Code, its current content is used, including unsaved changes.
Layout: drag the borders between the panels to resize them. The source and target panels are always shown; the Inspector button at the right of the toolbar shows or hides the Inspector & Output panel (Properties, XSLT, Validation, Logic Apps, Mapping JSON, Tests).
Links: drag from a source field to a target field or to a function input. Dropping onto a target that already has a link asks before replacing it.

Functions: add them with Add Function and connect them between fields.

Category	Functions
String	String Concatenate, Substring, Replace, Trim, To Uppercase, To Lowercase
Math	Add, Subtract, Multiply, Divide
Logic	If / Condition, Equal, Not Equal, Greater Than, Less Than
Date & Number	Date Format, Number Format
Value	Constant Value, Lookup Table
Advanced / Scripting	Inline XSLT Expression, XSLT Call Template, Inline C# Script, External Assembly, Custom Function

Auto Map: suggests links from field names, data types, position in the tree, enumerations and repetition; you choose which ones to apply.
Repeating records: link a repeating source record to a repeating target record to loop over it.
Mapping tabs: split a large map into several canvas tabs.
Several messages in one schema: when a schema has more than one top-level element, a drop-down in the Source Schema / Target Schema panel header selects the message (or shows all roots). The XSLT is built for the selected target message. A schema's BizTalk Root Reference is selected by default.

Checking a map

Tab	What it shows
Properties	Details of the selected field, function or link
XSLT	The generated XSLT, updated as you map
Validation	Errors and warnings before export: required target fields without a link, missing function inputs, schema warnings, profile compatibility
Logic Apps	Compatibility with Azure Logic Apps (Transform XML action, Data Mapper action)
Mapping JSON	The map as JSON
Tests	Test cases: an input message and, optionally, the expected output. Run them to see the result and the differences

Export profiles and exports

Choose the target runtime with Profile in the toolbar: BizTalk / .NET Framework (allows inline C# through msxsl:script), Azure Logic Apps, Standard XSLT 1.0 or Strict Portable XSLT 1.0.

The title bar … menu exports:

Export XSLT…: the map as an .xslt file.
Export Documentation…: an HTML document listing every link and function.
Export Package…: a .zip with the XSLT, the map, the schemas, documentation, validation and Logic Apps reports, and the test cases.
Export Options…: mapping comments in the XSLT, the export summary, C# compatibility (modern or legacy .NET Framework).

Working with map files


Editing	Every change is written into the map file; VS Code shows ● until you save
Ctrl+S / Save Map in the title bar	Saves the file, including a value you are still typing
Ctrl+Shift+S / … → Save Map As…	Saves as a new file
Ctrl+Z / Ctrl+Y	Undo / redo. Each action is one step: a deleted link, a moved function, a new link, an edited value
New maps	New Map and Open Sample Map (a complete purchase order → sales order example) open as unsaved tabs; the first save asks for a file name. Right-click a folder → DevScope Integration Toolkit › New › New Map… asks for a name (`Map1.map.json`) and creates the map in that folder
Several maps	Each map opens in its own tab
Editing the file as text, Git changes	The mapper reloads the map

Opening a map never changes the file. A .json file that isn't a map (or a map edited into invalid JSON) isn't shown as a map: the tab says why, with Open as Text, and shows the map again once the file is a valid map. To always open map files in the Data Mapper: right-click a map → Open With… → Configure default editor (a naming convention such as *.map.json helps).

Ctrl+Alt+M (macOS: Cmd+Alt+M) or Data Mapper in the status bar shows the last map used.

Namespaces in the exported XSLT

Every field is read and written in its own namespace, as declared by the schema:

elementFormDefault="qualified": all elements are in the schema's target namespace.
No elementFormDefault (the XML Schema default, also used by BizTalk): only the root element, and elements used by reference, are in the namespace; inner elements have none.
No targetNamespace: no namespace.

Supported XSD features

Sequences, choices (also nested), all, named and anonymous types, type extension and restriction, simple content with attributes, element references, xs:group and xs:attributeGroup, substitution groups (shown as a choice of the possible elements), recursive types (shown three levels deep), enumerations and patterns, several root elements.

Visual XSD Editor

Opens .xsd files as a tree with a properties grid, a live XSD preview and a generated sample instance.


Open	Right-click an `.xsd` → DevScope Integration Toolkit › Open in Visual XSD Editor, the button in an `.xsd` text editor's title bar, or Open With… → Visual XSD Editor
New schema	Right-click a folder → DevScope Integration Toolkit › New › New XSD Schema…, type a name: the schema is created there and opened. New on the Visual XSD Editor's row in the sidebar opens an unsaved schema instead; the first Ctrl+S asks for a file name
Generate from XML	Right-click an `.xml` message → DevScope Integration Toolkit › Generate XSD Schema…, type a name (`<Root>.xsd` is suggested): the schema is inferred from the message, created next to it and saved, together with a schema for each other namespace in the message. In an open editor, the wand button in the Schema heading replaces the schema shown with one inferred from a message you paste or open (Ctrl+Z gives the previous one back); schemas for other namespaces join the workspace (below). Records, fields, attributes, occurrences and data types are inferred; repeated elements are merged
Structure	Records, fields (elements), attributes, sequence / choice / all groups, any element / any attribute, element references. Insert as child or sibling from the context menu or with shortcuts (Alt+R, Alt+E, Alt+A, …)
Workspace	A tab can hold several schemas, listed in the drop-down above the tree and all edited in that tab: the file, the schemas it imports (found through their `schemaLocation`), schema files you add (+ Add Schema File…, or Open XSD File… in the Imports dialog; both list the other schemas of `Artifacts/Schemas` (tick several) before Browse…: a file already in the `Artifacts/Schemas` folder, or a subfolder of it, is used where it is; a file from anywhere else is copied next to the open file first, so imports get a plain `schemaLocation` that still works once deployed, and you're asked before a different file with the same name is replaced), new schemas (+ New Schema, whose File Name says where it will be saved) and the schemas Generate from XML creates for other namespaces. Remove from Workspace takes one out (the file isn't deleted). Unsaved schemas are marked ● in the drop-down; Ctrl+S saves the file and every unsaved schema (new ones next to the file) and the status bar lists what was saved. Ctrl+Z / Ctrl+Y undo and redo in the schema shown. Unsaved schemas are kept if VS Code closes and come back when the file is opened again; closing the tab asks whether to save them
Other schemas	An Element Reference points to a global element of another schema of the workspace, a record's Data Structure Type reuses a named type (a record with a Type Name) of this or another schema, and Imports… (on the schema node, or its Imports property) lists the imported namespaces. Each import is written as `xs:import` with the other file as `schemaLocation`
Edit	F2 renames, drag and drop moves; the properties grid sets types, occurrence, restrictions, namespaces and BizTalk properties such as Root Reference and Element FormDefault
Text view	Show XSD Source (`</>` in the title bar) opens the same file as text beside it; both stay in sync
Ctrl+S, Ctrl+Z / Ctrl+Y	Save, undo and redo the file, as for any file
C# classes	The class-shaped button in the title bar → Generate C# Classes: the schema (unsaved changes included) and the files it imports / includes go to Schema to C# (XSD side)
… menu	Save a Copy…, Copy XSD, Replace with XSD File…, Replace with Sample Schema, Reset to Empty Schema

The editor writes BizTalk-style schemas. When a file contains something it can't represent (xs:group, xs:attributeGroup, xs:include, simple content text, XML comments, flat file settings, …), a warning lists it on opening. Opening never changes the file, but the first visual edit rewrites the whole file in the editor's format and drops those parts. Use Open as Text for such files.

Visual JSON Schema Editor

Opens JSON Schema files as a property tree with a properties grid, a live JSON Schema preview and a generated sample instance.


Open	Right-click a `.json` → DevScope Integration Toolkit › Open in Visual JSON Schema Editor, the button in a `.json` text editor's title bar, or Open With… → Visual JSON Schema Editor
New schema	Right-click a folder → DevScope Integration Toolkit › New › New JSON Schema…, type a name: the schema is created there and opened. New on the Visual JSON Schema Editor's row in the sidebar opens an unsaved schema instead; the first Ctrl+S asks for a file name (suggesting `<Title>.schema.json`)
Generate from JSON	Right-click a `.json` message → DevScope Integration Toolkit › Generate JSON Schema…, type a name (`<name>.schema.json` is suggested): the schema is inferred from the message, created next to it and saved. In an open schema, the wand button in the Schema heading replaces the schema with one inferred from a message you paste or open (one Ctrl+Z gives the previous one back). Types (integer or number), properties (required when present in every occurrence), arrays (items merged), formats (date-time, date, time, email, uri, uuid) and nullable values are inferred; for a list of objects, the schema describes one item
Structure	Objects, arrays, strings, numbers, integers, booleans, null, `$ref`, `oneOf` / `anyOf` / `allOf`, any value, and reusable definitions (`$defs` / `definitions`). Insert as child or sibling from the context menu or with shortcuts (Alt+O, Alt+A, Alt+S, …); Extract to definition turns a subschema into a definition and a `$ref`
Edit	F2 renames, drag and drop moves; the properties grid sets type, required, nullable, format, lengths, ranges, pattern, enum, const, default, examples, deprecated, read/write only, and the draft (2020-12, 2019-09, draft-07)
Check	Problems (an unknown `$ref` target, minimum above maximum, an invalid pattern or default, …) are listed under the preview and marked in the tree
Text view	Show JSON Source (`</>` in the title bar) opens the same file as text beside it; both stay in sync
Ctrl+S, Ctrl+Z / Ctrl+Y	Save, undo and redo the file, as for any file
C# classes	The class-shaped button in the title bar → Generate C# Classes: the schema (unsaved changes included) goes to Schema to C# (JSON Schema side)
… menu	Save a Copy…, Copy JSON Schema, Replace with JSON Schema File…, Replace with Sample Schema, Reset to Empty Schema

Opening never changes the file. A visual edit rewrites the whole file in the editor's format, keeping the file's indentation and final newline. Some JSON Schema keywords can't be shown (for example patternProperties, if / then / else, tuple items, $comment): a warning lists them on opening, and the first edit asks before removing them. A JSON file that isn't a JSON Schema (such as package.json) isn't shown as a tree; use Open as Text.

Flat File Wizard

Turns a flat file sample into one of two outputs, chosen with the Output switch at the top:

XSD Schema (BizTalk / Logic Apps): a flat file schema for the Logic Apps Flat File Decoding / Flat File Encoding actions or BizTalk Server, like Visual Studio's Flat File Schema Wizard.
JSON + JSON Schema: the sample converted to JSON, and a JSON Schema that validates that JSON. The JSON Schema also holds the parsing rules in sasp: keywords (ignored by JSON Schema validators), so it can be imported again to parse other files.

Steps 1–3 are the same for both outputs. Switching keeps the sample, the records and fields and the line settings; the target namespace (XSD) and the schema $id (JSON), and the code page / encoding, are kept separately for each output. The wizard opens in one tab and remembers your work and the chosen output, also after restarting VS Code.


Open	Flat File Wizard in the sidebar, or right-click a sample file (`.csv`, `.txt`, `.dat`, `.prn`, `.tsv`) → DevScope Integration Toolkit › Open in Flat File Wizard to load and analyze it
1. Flat file sample	Paste a sample, Open File…, or Load example…; Analyze Sample detects the line ending, field delimiter, quotes, a header row, fixed-width columns, tagged records (`HDR`, `DTL`, `TRL`…) and groups of records, and suggests field types and date formats
2. Schema information	Root record name, target namespace (XSD) or schema `$id` (JSON), code page / encoding, line delimiter, child order, wrap and escape characters, header row, early termination, empty nodes / values
3. Records & fields	Add, move, nest and delete records; per record: tag, occurrence, delimited or positional; per field: name, type, date/time format, length, justification, pad character, optional. For positional records, click the ruler to add or remove field boundaries
4. Output (XSD)	XSD Schema, XML Preview (what Flat File Decoding produces from the sample) and Parse Report (problems found when reading the sample); Save Schema… saves the `.xsd` (UTF-8)
4. Output (JSON)	JSON Preview, JSON Schema + sasp and Parse Report; Save JSON… / Save JSON Schema… save the view shown (`.json` / `.schema.json`); Import Schema… loads a saved JSON Schema with `sasp:` keywords to parse the sample with it
Copy	Copies the view shown

An XSD from the wizard can be used as the source schema of a map: save it into the project's Artifacts/Schemas folder, then pick it with Load Schema… in the map's Source Schema panel.

Schema Validator

Validates a document against a schema and explains every problem in plain English. Choose the side with the Validate switch at the top:

XML + XSD: checks that the XML is well-formed and valid against the XSD, with libxml2 (the engine of xmllint).
JSON + JSON Schema: checks the JSON against a JSON Schema (draft 2020-12, 2019-09, 07 or 06, detected from $schema or chosen), with Ajv.


Open	Schema Validator in the sidebar; right-click an `.xml` / `.json` → DevScope Integration Toolkit › Schema Validator › Validate Document…; right-click an `.xsd` / JSON Schema `.json` → … › Validate a Document Against This Schema…; or the ✓ button in the title bar of the Visual XSD Editor and the Visual JSON Schema Editor. The file goes into its box; if the other box already holds something it validates at once, otherwise open or paste the schema (or document) and click Validate
Documents	Paste, Open File…, or Load Example. On the schema box (XSD / JSON Schema), Open File… lists the schemas of `Artifacts/Schemas` first, then Browse…. A box filled from a file shows the file's name; files open in VS Code are read with their unsaved changes
Validate	Validate (Ctrl+Enter). Each problem shows the line (click to select it), a plain-English explanation, the engine's message and, where possible, a Suggested fix with a preview and Apply fix (it changes the text in the box)
Save	Save to File on a box filled from a file writes the box's text (for example after Apply fix) into that file, as an edit in VS Code: the file opens beside the validator, unsaved – Ctrl+S saves it, Ctrl+Z undoes it. Any other box has Save As… (VS Code's Save dialog; files are saved as UTF-8, and if an XML / XSD box declares another encoding, such as `encoding="UTF-16"`, you are asked first: Change to UTF-8 (the declaration is changed), or for a UTF-16 declaration Save as UTF-16 (the file is saved in UTF-16, as declared), for other encodings Keep as Is). Afterwards the box shows that file
Tools	Generate Sample (a valid document made from the schema), Pretty Print, Filter by rule, Save Report… (a text report)
Problems panel	The problems of a box filled from a file are also shown in VS Code's Problems panel and underlined in the file, as long as the box holds the file's text. They disappear when the file is edited, when the box is changed or cleared, and when the validator tab is closed; validate again to refresh them

Switching between XML and JSON keeps each side's documents. The documents are not kept after closing the tab.

Workflow Diff

Compares an Old and a New workflow definition (Azure Logic Apps or Power Automate) and draws the flow, marking each trigger and action as unchanged, added, removed or modified. It reads the standard definition format: triggers, actions, runAfter, and the nested If / Switch / Foreach / Until / Scope actions.


Open	Workflow Diff in the sidebar, or select two `.json` files in the Explorer, right-click → DevScope Integration Toolkit › Compare Logic App Workflows: the first file selected is Old, the second is New, and they are compared at once
Definitions	Paste into the Old and New boxes, or Open File… on each box: it lists the workflow folders of the open folders (each with a `workflow.json`, shown by the workflow's name and path), then Browse… for any file (a file open in VS Code is read with its unsaved changes). A `workflow.json` is shown as `<workflow>/workflow.json`. Besides a bare definition, the boxes accept `{ "definition": … }`, a Logic App or flow exported from Azure or Power Automate (`properties.definition`) and an ARM template (`resources`)
Compare	Compare draws the flow; Load Example fills both boxes with a sample. Old Definition Design and New Definition Design draw one side alone, without marks
Reading the drawing	Green = added, red = removed, yellow = modified, grey = unchanged. A trigger that changed is marked the same way and says Trigger under its name. Removed actions are shown where they were in the old definition; the order follows the `runAfter` links of the new one
Field difference	Click an action to open a panel with its properties, changed lines highlighted. The button at the top of the panel (next to the close button) opens the same two texts in VS Code's own diff editor, read-only and in a new tab

The tab is reused and nothing is written to disk. The two boxes are not kept after closing the tab.

XPath Tester

Runs XPath 1.0 expressions against an XML document, highlights the matching nodes in a tree, and gives the XPath of any node you click.


Open	XPath Tester in the sidebar, or right-click an `.xml` file (or its tab) → DevScope Integration Toolkit › Test XPath…: the file goes into the XML box (a file open in VS Code is read with its unsaved changes)
XML	Paste, Open File… (`.xml`, `.xsd`, `.wsdl`, `.config`, `.xslt`, `.xsl`; up to 50 MB), or Load Example. Format indents the XML. The name of the file it came from is shown under the box until you change the XML
Evaluate	Type an expression and press Enter (or Evaluate); with Live on, it runs as you type. The example buttons under the box show common expressions. A node-set is listed in Results and highlighted in the Navigator; a number, string or boolean is shown as the result. Relative to selected node evaluates from the node selected in the tree instead of the document
Namespaces	Every namespace of the document is listed with its prefix; a default namespace (no prefix in the XML) gets `ns0`, `ns1`… because XPath 1.0 needs a prefix to reach it. Change a prefix in the table to use your own
Navigator	Click a node (element, attribute, text, comment) to see its XPath with prefixes and its local-name() form (as BizTalk writes it), with Use (evaluates it) and Copy, plus its name, namespace, value and outer XML. Expand All / Collapse
Copy	Copy Values copies the values of the results (one per line), or the number / string / boolean
Clear	The tab's title bar … menu → Clear empties the XML, the expression, the tree and the results (the history of expressions is kept)

The tab is reused and nothing is written to disk. The XML, the expression, the last 15 expressions (offered as you type) and your prefixes are kept, also after restarting VS Code, which reopens the tab.

Logic Apps JSON Path Tester

Builds the Logic Apps expression for any value of a JSON payload, tests expressions against it, and generates the schema for a Parse JSON action.


Open	Logic Apps JSON Path in the sidebar, or right-click a `.json` file (or its tab) → DevScope Integration Toolkit › Build Logic Apps Expressions…: the file goes into the JSON Payload box (a file open in VS Code is read with its unsaved changes)
JSON	Paste a trigger or action body, or its JSON Schema (for example from a Parse JSON action). Open File… lists the JSON Schemas of `Artifacts/Schemas`, then Browse… for any `.json` (up to 20 MB); Load Example and Example Schema show examples; Format indents the JSON. Auto-detect decides whether the text is a payload or a schema; choose Sample payload or JSON Schema to force it. The file's name is shown under the box until you change the JSON
The JSON is	Where the JSON comes from in the workflow: the trigger body (`triggerBody()`), the body of another action (`body('Action')`, give the action's name as it appears in the designer) or the current item inside a For each (`item()`). For each name is the loop used for values inside arrays; Null-safe adds `?` so a missing property gives null instead of an error
Navigator	The JSON as a tree, with each value's type (for a schema: required properties, formats). Click a node to build its expression. Expand All / Collapse
Expression	The expression of the selected node: as written in the expression editor, inside a text field (`@{…}`) and in code view; inside a For each loop (the loop's From and the current item's property, with `items()` and `item()`); and useful variants (default when null, conversions, comparisons). Copy each one, or Test it
Test Expression	Evaluates an expression against the payload and shows the result. Common functions are supported (`first`, `last`, `length`, `coalesce`, `string`, `int`, `concat`…); the chips under the box are examples
Parse JSON Schema	The schema to paste into a Parse JSON action, in the same shape as Logic Apps' Use sample payload to generate schema. When the box holds a schema, this tab shows a Sample Payload made from it instead. Copy copies it

The tab is reused and nothing is written to disk. The JSON, the options, the selected node and the test expression are kept, also after restarting VS Code, which reopens the tab.

Schema to C#

Generates C# classes from schemas, live as you type or change an option. The Generate from switch at the top shows one of two sides; each keeps its own schemas and options, and the tab opens on the side used last.


Open	Schema to C# in the sidebar; right-click one or more `.json` or `.xsd` files (or a file's tab) → DevScope Integration Toolkit › Generate C# Classes…; or the class-shaped button in the title bar of the Visual JSON Schema Editor or the Visual XSD Editor. These switch to the right side and replace its schemas with the files you chose (the first is the root / main schema); files open in VS Code are read with their unsaved changes. An `.xsd` brings the files it imports, includes or redefines (`schemaLocation`, relative paths, followed through further files)
Schemas	Each schema is a tab in the JSON Schemas / XSD Schemas panel; paste, edit, rename (File name) or close it there. New adds an empty tab, Open Files… (the schemas of `Artifacts/Schemas` to tick, then Browse…) and Open Folder… (every `.json` / `.xsd` in the folder and its subfolders, except `node_modules`, `.git`, `bin` and `obj`) add files, Load Example shows an example. References between files are found among the tabs by file name (JSON also by `$id`); a missing one is reported under the code
Save	Save .cs… opens VS Code's Save dialog next to the first schema; Copy copies the code

JSON Schema side: classes for System.Text.Json or Newtonsoft.Json from JSON Schemas (draft-04 to 2020-12).

Options Namespace, root class name (default: the schema's title), serializer, class or record, collection type (List<T>, ICollection<T>, T[]), double or decimal for number, init setters, nullable reference types, data annotations ([Required], [StringLength], [Range], [RegularExpression]…), file-scoped namespace

Mapping Objects become classes (allOf with one $ref becomes inheritance), string enums become enums with their JSON names, formats become DateTimeOffset, DateOnly, TimeOnly, TimeSpan, Guid, Uri, byte[], int / long; additionalProperties becomes a dictionary or extension data; defaults become initial values. What can't be mapped exactly (mixed oneOf, several types, tuples) becomes object, with a warning under the code

XSD side: XmlSerializer classes from XSD schemas, in the style of xsd.exe /classes /language:CS.

Options Namespace (/namespace), public fields instead of properties (/fields), Order on particle members (/order), INotifyPropertyChanged (/enableDataBinding), the auto-generated header. The equivalent xsd.exe command line is shown next to the options

Mapping Global elements become root classes (XmlRoot), named and anonymous complex types become classes (extensions become inheritance with XmlInclude), enumerations become enums (XmlEnum for values that aren't valid names), XSD built-in types map as xsd.exe does (DataType where needed), optional value types get a …Specified property, a wrapper of one repeating element becomes an array (XmlArray / XmlArrayItem), choices become Item / Items with a choice enum when needed, xs:any / xs:anyAttribute become XmlElement / XmlAttribute, defaults become DefaultValue and constructor values. Included schemas are marked included and don't name the output file

The tab is reused and nothing is written to disk until you save. Both sides' schemas and options are kept, also after restarting VS Code, which reopens the tab.

Commands

All commands are in the Command Palette under Data Mapper:, XSD Editor:, JSON Schema Editor:, Flat File Wizard:, Schema Validator:, Workflow Diff:, XPath Tester:, Logic Apps JSON Path Tester: and Schema to C#:.

Data Mapper	XSD Editor	JSON Schema Editor
New Map, Open Map…, Open Sample Map	New XSD Schema, Open XSD Schema…, Open in Visual XSD Editor, Generate XSD Schema…	New JSON Schema, Open JSON Schema…, Open in Visual JSON Schema Editor, Generate JSON Schema…
Open in Data Mapper	Show XSD Source	Show JSON Source
Save Map, Save Map As…	Save a Copy…, Copy XSD	Save a Copy…, Copy JSON Schema
Export XSLT…, Export Documentation…, Export Package…, Export Options…	Replace with XSD File…, Replace with Sample Schema, Reset to Empty Schema	Replace with JSON Schema File…, Replace with Sample Schema, Reset to Empty Schema
Clear Map, Reload Mapper, Open Data Mapper, Open Settings

Flat File Wizard: Open Flat File Wizard, Open in Flat File Wizard. Schema Validator: Open Schema Validator, Validate Document…, Validate a Document Against This Schema…. Workflow Diff: Open Workflow Diff. XPath Tester: Open XPath Tester, Test XPath…, Clear (title bar … menu). Logic Apps JSON Path Tester: Open Logic Apps JSON Path Tester, Build Logic Apps Expressions…. Schema to C#: Open Schema to C#, Generate C# Classes…, Generate C# Classes (JSON Schema / XSD editor title bar).

Settings

Setting	Default	Description
`dataMapper.schemaExtensions`	`[".xsd", ".xml"]`	File types that Load Schema… lists from Artifacts/Schemas (and offers in Browse…)
`dataMapper.mapExtensions`	`[".json"]`	File types that get DevScope Integration Toolkit › Open in Data Mapper in the right-click menu

Privacy and security

No network access. The tools can't load anything from, or send anything to, the internet.
No telemetry. The extension makes no network calls and collects nothing.
Limited file access. The tools only receive the files you open or right-click; files are written only to the file you opened or through a Save dialog.
Sandboxed. The tools run in VS Code webviews, without access to Node.js, the disk or a shell.

Known limitations

Data Mapper: xs:include and xs:import are not followed: types and elements from other files are not available (a warning is shown). The Visual XSD Editor loads the schemas a file imports (xs:import with a file schemaLocation) into its workspace; xs:include isn't followed.
A repeating choice in mixed order (e.g. Car, Truck, Car) is written grouped by element (Car, Car, Truck).
A schema inferred from a sample XML takes the fields of a repeating record from its first occurrence.
The Flat File Wizard can't open an existing .xsd (only JSON Schemas it made itself, with Import Schema…). The Visual XSD Editor doesn't keep flat file settings (record and field delimiters, positions, tags), so edit flat file schemas as text (it warns when one is opened).
The sasp: keywords are read only by the Flat File Wizard; Logic Apps' Flat File Decoding needs the XSD output. The Visual JSON Schema Editor doesn't keep sasp: keywords (it asks before removing them).
Schema Validator: xs:include / xs:import (XML) and remote $ref URLs (JSON) are not loaded; put everything in one schema. Apply fix changes the text in the validator; use Save to File to put it into the file.
Workflow Diff: an ARM template with several workflows compares the first one in each box. Only the actions' own properties are compared in each action's panel; the actions nested inside an If / Switch / Foreach / Until / Scope are separate boxes in the drawing.
Schema to C#, XSD side: xs:redefine is treated as an include, abstract elements' substitution groups aren't expanded, a repeating sequence becomes separate arrays (like xsd.exe); imported / included files on web addresses aren't fetched.
Schema to C#, JSON Schema side: patternProperties next to properties, if / then / else, dependentSchemas and tuple arrays aren't turned into C# types; $ref to files is resolved only from the schemas loaded in the tab.
XPath Tester: XPath 1.0 only (the browser's engine), so XPath 2.0 / 3.1 functions are not available. The tree shows comments, text and processing instructions but not the DOCTYPE.
Logic Apps JSON Path Tester: Test Expression evaluates common functions only (not every Logic Apps function), and expressions that read other actions, variables or parameters can't be evaluated; the expressions it builds are the ones to use in the workflow.
Inline C# runs in a limited simulator for previews and tests; the exported XSLT needs a .NET (BizTalk) runtime to execute it.

Requirements

VS Code 1.85 or later.

Development

npm install
npm test           # all tests (see test/README.md)
npm run package    # builds the .vsix

Press F5 in VS Code to run the extension from source.

Path	Contents
`extension.js`	Entry point: registers the tools
`dataMapper.js`, `xsdEditor.js`, `jsonSchemaEditor.js`, `flatFileWizard.js`	Each tool's VS Code side: custom editor, commands, sync with the file
`webviewHost.js`	Shared: loads a tool page into a webview (security policy, storage) and answers its requests (dialogs, Save dialog, clipboard)
`media/mapper/`	The Data Mapper page: `mapper.html`, `mapper.css`, `js/01-…16-*.js` (loaded in number order), `vscode.js` (connection to `dataMapper.js`), `empty-map.json` / `sample-map.json` (new maps, made by `npm run new-maps`)
`media/xsd-editor/`	The XSD editor page and its `vscode.js`
`media/json-schema-editor/`	The JSON Schema editor page and its `vscode.js`
`schemaValidator.js`	The Schema Validator's VS Code side: tab, files, Problems panel
`workflowDiff.js`, `media/workflow-diff/`	Workflow Diff: its VS Code side (tab, files, the diff editor) and the page (`workflow-diff.html`, `workflow-diff.css`, `vscode.js`)
`toolsView.js`	The sidebar's three sections (Edit, Generate, Test & Compare): a row per tool, New / Open on the editors' rows
`schemaToCsharp.js`, `media/schema-to-csharp/`	Schema to C#: its VS Code side (tab, the two sides, files and the XSD files they import, folders, Save dialog, restore after restart) and the pages (`json-schema-to-csharp.html`, `xsd-to-csharp.html`, the shared `schema-to-csharp.css` and `vscode.js`)
`xpathTester.js`, `media/xpath-tester/`	XPath Tester: its VS Code side (tab, files, restore after restart) and the page (`xpath-tester.html`, `xpath-tester.css`, `vscode.js`)
`jsonPathTester.js`, `media/json-path-tester/`	Logic Apps JSON Path Tester: its VS Code side (tab, files, restore after restart) and the page (`json-path-tester.html`, `json-path-tester.css`, `vscode.js`)
`artifactPicker.js`	Shared: the Open File… pickers (the schemas of `Artifacts/Schemas`, or the folders with a `workflow.json`, then Browse…)
`media/schema-validator/`	The Schema Validator: `xml-validator.html`, `json-validator.html`, `validator.css`, `vscode.js`, `libxml2-xsd.js` (libxml2 as WebAssembly), `ajv/` (Ajv), `licenses/`
`media/flat-file-wizard/`	The Flat File Wizard: `flat-file-wizard.html` (XSD output), `flat-file-json-wizard.html` (JSON output), `wizard.css` (their shared look) and `vscode.js`
`media/shared/bridge.js`	Runs first in every page: messages, dialogs, downloads, storage, error reporting
`test/`	Tests and sample schemas (not packaged)
`CHANGES-FROM-UPSTREAM.md`	How the tool pages differ from the original HTML tools

Credits

Based on the Data Mapper, Visual XSD Editor, Visual JSON Schema Editor, Flat File Schema Wizard, Flat File to JSON Wizard, XML ↔ XSD Validator, JSON Schema Validator, Workflow Diff, XPath Tester & XML Navigator, Logic Apps JSON Path Tester, JSON Schema to C# and XSD to C# of DevScope's Azure Enterprise Integration Toolkit.
The DevScope wordmark shown in the tools belongs to DevScope.
Icons: Codicons (CC BY 4.0; code MIT), bundled in media/codicons.
Schema Validator engines, bundled in media/schema-validator (licences in media/schema-validator/licenses): libxml2 (MIT) compiled to WebAssembly by libxml2-wasm (MIT), and Ajv 8.17.1 (MIT).

License

See the LICENSE file.