Edge.js: run .NET and Node.js in-process on Windows, Mac OS, and Linux
npm install @indigo/edgeAbout this Fork
====
This is a fork of tjanczuk/edge intended to fix bugs, mainly regarding .Net Core support.
Branches:
* master: it only updates this README
* indigo-edge: where fixes are commited
* indigo-publish: to publish npm package @indigo/edge
If you want to use this fork:
``
`
npm install @indigo/edge
require("@indigo/edge")
`
CONTRIBUTING
====
- First open an issue to discuss the intended change.
- PRs should be made against indigo-edge branch.
Edge.js: .NET and Node.js in-process 
====
NEW Edge.js is now on Slack at https://edgejs.slack.com. Join here.
An edge connects two nodes. This edge connects Node.js and .NET. V8 and CLR/.NET Core/Mono - in process. On Windows, MacOS, and Linux.
!image
You can script C# from a Node.js process:
ES5
javascript
`
var edge = require('edge');
var helloWorld = edge.func(function () {/*
async (input) => {
return ".NET Welcomes " + input.ToString();
}
*/});
helloWorld('JavaScript', function (error, result) {
if (error) throw error;
console.log(result);
});
`
ES6
In ES6 you can use template strings to write multiline C# code.
javascript
var edge = require('edge');
var helloWorld = edge.func(
async (input) => {
return ".NET Welcomes " + input.ToString();
}
);
`
helloWorld('JavaScript', function (error, result) {
if (error) throw error;
console.log(result);
});
`
You can also script Node.js from C#:
c#
`
using System;
using System.Threading.Tasks;
using EdgeJs;
class Program
{
public static async Task Start()
{
var func = Edge.Func(@"
return function (data, callback) {
callback(null, 'Node.js welcomes ' + data);
}
");
Console.WriteLine(await func(".NET"));
}
static void Main(string[] args)
{
Start().Wait();
}
}
`
What problems does Edge.js solve?
> Ah, whatever problem you have. If you have this problem, this solves it.
--Scott Hanselman (@shanselman)
Before you dive in
See the Edge.js overview.
Read the Edge.js introduction on InfoQ.
Listen to the Edge.js podcast on Herdingcode.
!image
Contents
Introduction
Scripting CLR from Node.js
What you need
Windows
Linux
OSX
Docker
How to: C# hello, world
How to: integrate C# code into Node.js code
How to: specify additional CLR assembly references in C# code
How to: marshal data between C# and Node.js
How to: call Node.js from C#
How to: export C# function to Node.js
How to: script Python in a Node.js application
How to: script PowerShell in a Node.js application
How to: script F# in a Node.js application
How to: script Lisp in a Node.js application
How to: script T-SQL in a Node.js application
How to: support for other CLR languages
How to: exceptions
How to: app.config
How to: debugging
Performance
Building on Windows
Building on OSX
Building on Linux
Running tests
Scripting Node.js from CLR
What you need
How to: Node.js hello, world
How to: integrate Node.js into CLR code
How to: use Node.js built-in modules
How to: use external Node.js modules
How to: handle Node.js events in .NET
How to: expose Node.js state to .NET
How to: use Node.js in ASP.NET application
How to: debug Node.js code running in a CLR application
Building Edge.js NuGet package
Running tests of scripting Node.js in C#
Use cases and other resources
Contribution and derived work
Introduction
Edge.js allows you to run Node.js and .NET code in one process on Windows, MacOS, and Linux.
You can call .NET functions from Node.js and Node.js functions from .NET. Edge.js takes care of marshalling data between CLR and V8. Edge.js also reconciles threading models of single threaded V8 and multi-threaded CLR. Edge.js ensures correct lifetime of objects on V8 and CLR heaps. The CLR code can be pre-compiled or specified as C#, F#, Python, or PowerShell source: Edge.js can compile CLR scripts at runtime. Edge can be extended to support other CLR languages or DSLs.
!Edge.js interop model
Edge.js provides an asynchronous, in-process mechanism for interoperability between Node.js and .NET. You can use this mechanism to:
* script Node.js from a .NET application (console app, ASP.NET, etc.)
* script C# from a Node.js application on Windows, MacOS, and Linux
* access MS SQL from Node.js using ADO.NET more...
* use CLR multi-threading from Node.js for CPU intensive work more...
* write native extensions to Node.js in C# instead of C/C++
* integrate existing .NET components into Node.js applications
Read more about the background and motivations of the project here.
Follow @tjanczuk for updates related to the module.
Scripting CLR from Node.js
If you are writing a Node.js application, this section explains how you include and run CLR code in your app. It works on Windows, MacOS, and Linux.
$3
Edge.js runs on Windows, Linux, and OSX and requires Node.js 7.x, 6.x, 5.x, 4.x, as well as .NET Framework 4.5 (Windows), Mono 4.2.4 (OSX, Linux), or .NET Core 1.0.0 Preview 2 (Windows, OSX, Linux).
NOTE there is a known issue with Mono after 4.2.4 that will be addressed in Mono 4.6.
#### Windows
* Node.js 7.x, 6.x, 5.x, or 4.x
* .NET 4.5 and/or .NET Core
* to use Python, you also need IronPython 2.7.3 or later
* to use F#, read Dave Thomas blog post
If you have both desktop CLR and .NET Core installed, read using .NET Core for how to configure Edge to use one or the other.
!image
#### Linux
* Node.js 7.x, 6.x, 5.x, or 4.x
* Mono 4.2.4 x64 and/or .NET Core
* Follow Linux setup instructions
!image
#### OSX
* Node.js 7.x, 6.x, 5.x, or 4.x,
* Mono 4.2.4 x64 and/or .NET Core
* Follow OSX setup instructions
!image
#### Docker
Edge.js is available as a Docker image on the tjanczuk/edgejs repository on Docker Hub. The image is based on Debian Trusty, and contains Node.js 6.3.0 x64, Mono 4.2.4 x64, .NET Core 1.0.0 Preview 2 x64 (dotnet-dev-1.0.0-preview2-003121), and Edge.js 6.5.1:
By default Edge uses Mono to execute CLR code:
`
> docker run -it tjanczuk/edgejs:6.5.1
> cd samples
> node 101_hello_lambda.js
.NET welcomes Node.js
EDGE_USE_CORECLR=1
Specify the environment variable to use .NET Core instead:
`
`
> docker run -it tjanczuk/edgejs:6.5.1
> cd samples
> EDGE_USE_CORECLR=1 node 101_hello_lambda.js
.NET welcomes Node.js
EDGE_USE_CORECLR
Alternatively, you can also specify when starting the container:
`
`
> docker run -it -e EDGE_USE_CORECLR=1 tjanczuk/edgejs:6.5.1
`
$3
Follow setup instructions for your platform.
Install edge:
`
npm install edge
`
In your server.js:
javascript
`
var edge = require('edge');
var helloWorld = edge.func(function () {/*
async (input) => {
return ".NET Welcomes " + input.ToString();
}
*/});
helloWorld('JavaScript', function (error, result) {
if (error) throw error;
console.log(result);
});
`
Run and enjoy:
`
$>node server.js
.NET welcomes JavaScript
EDGE_USE_CORECLR
If you want to use .NET Core as your runtime and are running in a dual runtime environment (i.e. Windows with .NET 4.5 installed as well or Linux with Mono installed), you will need to tell edge to use .NET Core by setting the environment variable:
`
`
$>EDGE_USE_CORECLR=1 node server.js
.NET Welcomes JavaScript
Func
$3
Edge provides several ways to integrate C# code into a Node.js application. Regardless of the way you choose, the entry point into the .NET code is normalized to a delegate. This allows Node.js code to call .NET asynchronously and avoid blocking the Node.js event loop.
Func
Edge provides a function that accepts a reference to C# code in one of the supported representations, and returns a Node.js function which acts as a JavaScript proxy to the .NET delegate:
`
javascript
`
var edge = require('edge');
var myFunction = edge.func(...);
`
The function proxy can then be called from Node.js like any asynchronous function:
javascript
`
myFunction('Some input', function (error, result) {
//...
});
`
Alternatively, if you know the C# implementation will complete synchronously given the circumstances, you can call this function as any synchronous JavaScript function as follows:
javascript
`
var result = myFunction('Some input', true);
true
The parameter instead of a callback indicates that Node.js expects the C# implementation to complete synchronously. If the CLR function implementation does not complete synchronously, the call above will result in an exception.
Func
One representation of CLR code that Edge.js accepts is C# source code. You can embed C# literal representing a .NET async lambda expression implementing the delegate directly inside Node.js code:
`
javascript
`
var add7 = edge.func('async (input) => { return (int)input + 7; }');
`
In another representation, you can embed multi-line C# source code by providing a function with a body containing a multi-line comment. Edge extracts the C# code from the function body using regular expressions:
javascript
`
var add7 = edge.func(function() {/*
async (input) => {
return (int)input + 7;
}
*/});
`
Or if you use ES6 you can use template strings to define a multiline string:
javascript
var add7 = edge.func(
async (input) => {
return (int)input + 7;
}
);
`
Startup
If your C# code is more involved than a simple lambda, you can specify entire class definition. By convention, the class must be named and it must have an Invoke method that matches the Func delegate signature. This method is useful if you need to factor your code into multiple methods:
`
javascript
`
var add7 = edge.func(function() {/*
using System.Threading.Tasks;
public class Startup
{
public async Task
.csx
If your C# code grows substantially, it is useful to keep it in a separate file. You can save it to a file with or .cs extension, and then reference from your Node.js application:
`
javascript
`
var add7 = edge.func(require('path').join(__dirname, 'add7.csx'));
`
If you integrate C# code into your Node.js application by specifying C# source using one of the methods above, edge will compile the code on the fly. If you prefer to pre-compile your C# sources to a CLR assembly, or if your C# component is already pre-compiled, you can reference a CLR assembly from your Node.js code. In the most generic form, you can specify the assembly file name, the type name, and the method name when creating a Node.js proxy to a .NET method:
javascript
`
var clrMethod = edge.func({
assemblyFile: 'My.Edge.Samples.dll',
typeName: 'Samples.FooBar.MyType',
methodName: 'MyMethod' // This must be Func
});
Invoke
If you don't specify methodName, is assumed. If you don't specify typeName, a type name is constructed by assuming the class called Startup in the namespace equal to the assembly file name (without the .dll). In the example above, if typeName was not specified, it would default to My.Edge.Samples.Startup.
__dirname
The assemblyFile is relative to the working directory. If you want to locate your assembly in a fixed location relative to your Node.js application, it is useful to construct the assemblyFile using . If you are using .NET Core, assemblyFile can also be a project name or NuGet package name that is specified in your project.json or .deps.json dependency manifest.
`
You can also create Node.js proxies to .NET functions specifying just the assembly name as a parameter:
javascript
`
var clrMethod = edge.func('My.Edge.Samples.dll');
My.Edge.Samples.Startup
In that case the default typeName of and methodName of Invoke is assumed as explained above.
`
$3
When you provide C# source code and let edge compile it for you at runtime, edge will by default reference only mscorlib.dll and System.dll assemblies. If you're using .NET Core, we automatically reference the most recent versions of the System.Runtime, System.Threading.Tasks, System.Dynamic.Runtime, and the compiler language packages, like Microsoft.CSharp. In applications that require additional assemblies you can specify them in C# code using a special hash pattern, similar to Roslyn. For example, to use ADO.NET you must reference System.Data.dll:
javascript
`
var add7 = edge.func(function() {/*
#r "System.Data.dll"
using System.Data;
using System.Threading.Tasks;
public class Startup
{
public async Task
edge.func
If you prefer, instead of using comments you can specify references by providing options to the call:
`
javascript
`
var add7 = edge.func({
source: function() {/*
using System.Data;
using System.Threading.Tasks;
public class Startup
{
public async Task
project.json
If you are using .NET Core and are using the .NET Core SDK and CLI, you must have a file (specification here) that specifies the dependencies for the application. This list of dependencies must also include the Edge.js runtime package and, if you need to be able to dynamically compile your code, the package(s) for the compilers that you plan to use, like Edge.js.CSharp. You must have run the dotnet restore (to restore the dependencies) and dotnet build (to build your project and generate the dependency manifest) commands in that project's directory to generate a .deps.json file under bin/[configuration]/[framework], i.e. bin/Release/netstandard1.6/MyProject.deps.json. This .deps.json file must either be in the current working directory that node is executed in or you must specify its directory by setting the EDGE_APP_ROOT environment variable. For example, if for a netstandard1.6 project in the c:\DotNet\MyProject directory, you would run something like:
`
`
set EDGE_APP_ROOT=c:\DotNet\MyProject\bin\Release\netstandard1.6
node app.js
project.json
Edge.js also supports running published .NET Core applications on servers that do not have the .NET Core SDK and CLI installed, which is a common scenario in production environments. To do so, the for your application should meet the following requirements:
netcoreapp1.0
1. It should target the framework moniker.
Microsoft.NETCore.DotNetHost
2. It should reference and Microsoft.NETCore.DotNetHostPolicy. This is required so that the publish process can provide all the native libraries required to create a completely standalone version of your application.
"emitEntryPoint": true
3. should be present under buildOptions. You can add an empty Main() implementation to your project to accomodate it; this method will not be called, but is just a requirement in order for dotnet publish to generate a completely standalone app.
dotnet publish -r [target runtime for your production server]
On your development machine, you would run (i.e. dotnet publish -r ubuntu.14.04-x64) to aggregate the package assemblies and native libraries necessary to run your application. You can copy the contents of the publish directory up to your SDK- and CLI-less server and use them directly in Edge.js by setting the EDGE_APP_ROOT environment variable to the directory on the server that you copied the published application to.
Buffer
$3
Edge.js can marshal any JSON-serializable value between .NET and Node.js (although JSON serialization is not used in the process). Edge also supports marshalling between Node.js instance and a CLR byte[] array to help you efficiently pass binary data.
`
You can call .NET from Node.js and pass in a complex JavaScript object as follows:
javascript
`
var dotNetFunction = edge.func('Edge.Sample.dll');
var payload = {
anInteger: 1,
aNumber: 3.1415,
aString: 'foo',
aBoolean: true,
aBuffer: new Buffer(10),
anArray: [ 1, 'foo' ],
anObject: { a: 'foo', b: 12 }
};
dotNetFunction(payload, function (error, result) { });
IDictionary
In .NET, JavaScript objects are represented as dynamics (which can be cast to if desired), JavaScript arrays as object[], and JavaScript Buffer as byte[]. Scalar JavaScript values have their corresponding .NET types (int, double, bool, string). Here is how you can access the data in .NET:
`
c#
`
using System.Threading.Tasks;
public class Startup
{
public async Task
Person
Similar type marshalling is applied when .NET code passes data back to Node.js code. In .NET code you can provide an instance of any CLR type that would normally be JSON serializable, including domain specific types like or anonymous objects. For example:
`
c#
`
using System.Threading.Tasks;
public class Person
{
public int anInteger = 1;
public double aNumber = 3.1415;
public string aString = "foo";
public bool aBoolean = true;
public byte[] aBuffer = new byte[10];
public object[] anArray = new object[] { 1, "foo" };
public object anObject = new { a = "foo", b = 12 };
}
public class Startup
{
public async Task
`
In your Node.js code that invokes this .NET method you can display the result object that the callback method receives:
javascript
`
var edge = require('edge');
var getPerson = edge.func(function () {/*
using System.Threading.Tasks;
public class Person
{
public int anInteger = 1;
public double aNumber = 3.1415;
public string aString = "foo";
public bool aBoolean = true;
public byte[] aBuffer = new byte[10];
public object[] anArray = new object[] { 1, "foo" };
public object anObject = new { a = "foo", b = 12 };
}
public class Startup
{
public async Task
`
Passing this .NET object to Node.js generates a JavaScript object as follows:
`
$>node sample.js
{ anInteger: 1,
aNumber: 3.1415,
aString: 'foo',
aBoolean: true,
aBuffer:
anArray: [ 1, 'foo' ],
anObject: { a: 'foo', b: 12 } }
EDGE_ENABLE_SCRIPTIGNOREATTRIBUTE
When data is marshalled from .NET to Node.js, no checks for circular references are made. They will typically result in stack overflows. Make sure the object graph you are passing from .NET to Node.js is a tree and does not contain any cycles.
WINDOWS ONLY When marshalling strongly typed objects (e.g. Person) from .NET to Node.js, you can optionally tell Edge.js to observe the System.Web.Script.Serialization.ScriptIgnoreAttribute. You opt in to this behavior by setting the environment variable:
`
`
set EDGE_ENABLE_SCRIPTIGNOREATTRIBUTE=1
add
Edge.js by default does not observe the ScriptIgnoreAttribute to avoid the associated performance cost.
$3
In addition to marshalling data, edge can marshal proxies to JavaScript functions when invoking .NET code from Node.js. This allows .NET code to call back into Node.js.
Suppose the Node.js application passes an function to the .NET code as a property of an object. The function receives two numbers and returns the sum of them via the provided callback:
`
javascript
`
var edge = require('edge');
var addAndMultiplyBy2 = edge.func(function () {/*
async (dynamic input) => {
var add = (Func
var twoNumbers = new { a = (int)input.a, b = (int)input.b };
var addResult = (int)await add(twoNumbers);
return addResult * 2;
}
*/});
var payload = {
a: 2,
b: 3,
add: function (data, callback) {
callback(null, data.a + data.b);
}
};
addAndMultiplyBy2(payload, function (error, result) {
if (error) throw error;
console.log(result);
});
add
The .NET code implements the addAndMultiplyBy2 function. It extracts the two numbers passed from Node.js, calls back into the function exported from Node.js to add them, multiplies the result by 2 in .NET, and returns the result back to Node.js:
`
`
$>node sample.js
10
`
The Node.js function exported from Node.js to .NET must follow the prescriptive async pattern of accepting two parameters: payload and a callback. The callback function accepts two parameters. The first one is the error, if any, and the second the result of the operation:
javascript
`
function (payload, callback) {
var error; // must be null or undefined in the absence of error
var result;
// do something
callback(error, result);
}
`
The proxy to that function in .NET has the following signature:
c#
`
Func
await
Using TPL in CLR to provide a proxy to an asynchronous Node.js function allows the .NET code to use the convenience of the keyword when invoking the Node.js functionality. The example above shows the use of the await keyword when calling the proxy of the Node.js add method.
Func
$3
Similarly to marshalling functions from Node.js to .NET, Edge.js can also marshal functions from .NET to Node.js. The .NET code can export a delegate to Node.js as part of the return value of a .NET method invocation. For example:
`
javascript
`
var createHello = edge.func(function () {/*
async (input) =>
{
return (Func
Console.WriteLine("Hello from .NET");
return null;
});
}
*/});
var hello = createHello(null, true);
hello(null, true); // prints out "Hello from .NET"
`
This mechanism in conjunction with a closure can be used to expose CLR class instances or CLR state in general to JavaScript. For example:
javascript
`
var createCounter = edge.func(function () {/*
async (input) =>
{
var k = (int)input;
return (Func
}
*/});
var counter = createCounter(12, true); // create counter with 12 as initial state
console.log(counter(null, true)); // prints 13
console.log(counter(null, true)); // prints 14
`
$3
NOTE This functionality requires IronPython and has been tested on Windows only.
Edge.js enables you to run Python and Node.js in-process.
In addition to platform specific prerequisites you need IronPython 2.7.3 to proceed.
#### Hello, world
Install edge and edge-py modules:
`
npm install edge
npm install edge-py
`
In your server.js:
javascript
`
var edge = require('edge');
var hello = edge.func('py', function () {/*
def hello(input):
return "Python welcomes " + input
lambda x: hello(x)
*/});
hello('Node.js', function (error, result) {
if (error) throw error;
console.log(result);
});
`
Run and enjoy:
`
$>node py.js
Python welcomes Node.js
edge.func
#### The interop model
Your Python script must evaluate to a lambda expression that accepts a single parameter. The parameter represents marshalled input from the Node.js code. The return value of the lambda expression is passed back as the result to Node.js code. The Python script can contain constructs (e.g. Python functions) that are used in the closure of the lambda expression. The instance of the script with associated state is created when is called in Node.js. Each call to the function referes to that instance.
`
The simplest echo Python script you can embed in Node.js looks like this:
python
`
lambda x: x
`
To say hello, you can use something like this:
python
`
lambda: x: "Hello, " + x
`
To maintain a running sum of numbers:
python
`
current = 0
def add(x):
global current
current = current + x
return current
lambda x: add(x)
`
#### Python in its own file
You can reference Python script stored in a *.py file instead of embedding Python code in a Node.js script.
In your hello.py file:
python
`
def hello(input):
return "Python welcomes " + input
lambda x: hello(x)
`
In your hello.js file:
javascript
`
var edge = require('edge');
var hello = edge.func('py', 'hello.py');
hello('Node.js', function (error, result) {
if (error) throw error;
console.log(result);
});
`
Run and enjoy:
`
$>node hello.js
Python welcomes Node.js
`
#### To sync or to async, that is the question
In the examples above Python script was executing asynchronously on its own thread without blocking the singleton V8 thread on which the Node.js event loop runs. This means your Node.js application remains responsive while the Python code executes in the background.
If you know your Python code is non-blocking, or if you know what you are doing, you can tell Edge.js to execute Python code on the singleton V8 thread. This will improve performance for non-blocking Python scripts embedded in a Node.js application:
javascript
`
var edge = require('edge');
var hello = edge.func('py', {
source: function () {/*
def hello(input):
return "Python welcomes " + input
lambda x: hello(x)
*/},
sync: true
});
console.log(hello('Node.js', true));
sync: true
The property in the call to edge.func tells Edge.js to execute Python code on the V8 thread as opposed to creating a new thread to run Python script on. The true parameter in the call to hello requests that Edge.js does in fact call the hello function synchronously, i.e. return the result as opposed to calling a callback function.
`
$3
NOTE This functionality only works on Windows.
Edge.js enables you to run PowerShell and Node.js in-process on Windows. Edge-PS connects the PowerShell ecosystem with Node.js.
You need Windows, Node.js, .NET 4.5, and PowerShell 3.0 to proceed.
$3
Install edge and edge-ps modules:
`
npm install edge
npm install edge-ps
`
In your server.js:
javascript
`
var edge = require('edge');
var hello = edge.func('ps', function () {/*
"PowerShell welcomes $inputFromJS on $(Get-Date)"
*/});
hello('Node.js', function (error, result) {
if (error) throw error;
console.log(result[0]);
});
`
Run and enjoy:
`
C:\testEdgeps>node server
PowerShell welcomes Node.js on 05/04/2013 09:38:40
`
#### Tapping into PowerShell's ecosystem
Rather than embedding PowerShell directly, you can use PowerShell files, dot source them and even use Import-Module.
What you can do in native PowerShell works in Node.js.
#### Interop PowerShell and Python
Here you can reach out to IronPython from PowerShell from within Node.js on Windows. This holds true for working with JavaScript frameworks and C#.
javascript
`
var edge = require('edge');
var helloPowerShell = edge.func('ps', function () {/*
"PowerShell welcomes $inputFromJS"
*/});
var helloPython = edge.func('py', function () {/*
def hello(input):
return "Python welcomes " + input
lambda x: hello(x)
*/});
helloPython('Node.js', function(error, result){
if(error) throw error;
helloPowerShell(result, function(error, result){
if(error) throw error;
console.log(result[0]);
});
});
`
$3
NOTE This functionality has not been tested on non-Windows platforms.
This section is coming up. In the meantime please refer to Dave Thomas blog post. This has been validated on Windows only.
javascript
`
var edge = require('edge');
var helloFs = edge.func('fs', function () {/*
fun input -> async {
return "F# welcomes " + input.ToString()
}
*/});
helloFs('Node.js', function (error, result) {
if (error) throw error;
console.log(result);
});
`
$3
NOTE This functionality has not been tested on non-Windows platforms.
The edge-lsharp extension uses LSharp to compile and run Lisp to .NET.
Install edge and edge-lsharp modules:
`
npm install edge
npm install edge-lsharp
`
In your server.js:
javascript
`
var edge = require('edge');
var fact = edge.func('lsharp', function(){/*
;; Factorial
(def fact(n)
(if (is n 0) 1 (* n (fact (- n 1)))))
*/});
fact([5], function(err, answer){
console.log(answer);
// = 120
});
`
An LSharp filename can be passed in instead of the Lisp string/comment:
js
`
var edge = require('edge');
var lisp = edge.func('lsharp', 'lisp-func.ls');
lisp(['arg1', 'arg2'], function(err, result){
});
`
In Lisp you can specify either a function (as shown in the first example) or just return a value:
js
`
var edge = require('edge');
var lisp = edge.func('lsharp', '(+ 2 3)');
lisp([], function(err, answer){
console.log(answer);
// = 5
});
`
$3
NOTE This functionality has only been tested on Windows. Although ADO.NET exist in Mono, your mileage can vary.
The edge-sql extension of Edge.js allows for accessing MS SQL databases by scripting T-SQL inside the Node.js application. The edge-sql extension uses async ADO.NET SQL client to access MS SQL.
You need Windows, Node.js, and .NET 4.5. To run the sample code below you also need a connection string to the sample Northwind database that ships with MS SQL.
#### Hello, world
Install edge and edge-sql modules:
`
npm install edge
npm install edge-sql
`
Set the connection string as an environment variable (your connection string may be different):
`
set EDGE_SQL_CONNECTION_STRING=Data Source=localhost;Initial Catalog=Northwind;Integrated Security=True
`
In your server.js:
javascript
`
var edge = require('edge');
var getTop10Products = edge.func('sql', function () {/*
select top 10 * from Products
*/});
getTop10Products(null, function (error, result) {
if (error) throw error;
console.log(result);
console.log(result[0].ProductName);
console.log(result[1].ReorderLevel);
});
`
Run and enjoy:
`
C:\projects\edge\samples>node server.js
[ { ProductID: 10,
ProductName: 'New Ikura',
SupplierID: 4,
CategoryID: 8,
QuantityPerUnit: '12 - 200 ml jars',
UnitPrice: '31.000',
UnitsInStock: 31,
UnitsOnOrder: 0,
ReorderLevel: 0,
Discontinued: false },
...
]
New Ikura
12
`
#### Parameterized queries
You can construct a parameterized query once and provide parameter values on a per-call basis:
javascript
`
var edge = require('edge');
var getProduct = edge.func('sql', function () {/*
select * from Products
where ProductId = @myProductId
*/});
getProduct({ myProductId: 10 }, function (error, result) {
if (error) throw error;
console.log(result);
});
`
#### Basic CRUD support: select, update, insert, delete
The four basic CRUD operations are supported. For example, here is how an update can look like:
javascript
`
var edge = require('edge');
var updateProductName = edge.func('sql', function () {/*
update Products
set ProductName = @newName
where ProductId = @myProductId
*/});
updateProductName({ myProductId: 10, newName: 'New Ikura' }, function (error, result) {
if (error) throw error;
console.log(result);
});
Func
$3
Edge.js can work with any pre-compiled CLR assembly that contains the delegate. Out of the box, Edge.js also allows you to embed C# source code in a Node.js application and compile it on the fly.
error
To enable compilation of other CLR languages (e.g. F#) at runtime, or to support domain specific languages (DSLs) like T-SQL, you can use the compiler composability model provided by Edge.js. Please read the add support for a CLR language guide to get started.
$3
Edge.js marshals Node.js errors and exceptions to .NET as well as .NET exceptions to Node.js.
CLR exceptions thrown in .NET code invoked from Node.js are marshalled as the parameter to the Node.js callback function. Consider this example:
`
javascript
`
var edge = require('edge');
var clrFunc = edge.func(function () {/*
async (dynamic input) => {
throw new Exception("Sample exception");
}
*/});
clrFunc(null, function (error, result) {
if (error) {
console.log('Is Error?', error instanceof Error);
console.log('-----------------');
console.log(util.inspect(error, showHidden=true, depth=99, colorize=false));
return;
}
});
error
Running this Node.js application shows that the CLR exception was indeed received by the Node.js callback. The parameter contains an Error object having most of the properties of the Exceptions copied over:
`
1[[System.Exception, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]',
Is Error? true
-----------------
{ [System.AggregateException: One or more errors occurred.]
message: 'One or more errors occurred.',
name: 'System.AggregateException',
InnerExceptions: 'System.Collections.ObjectModel.ReadOnlyCollection
Message: 'One or more errors occurred.',
Data: 'System.Collections.ListDictionaryInternal',
InnerException:
{ [System.Exception: Sample exception]
message: 'Sample exception',
name: 'System.Exception',
Message: 'Sample exception',
Data: 'System.Collections.ListDictionaryInternal',
TargetSite: 'System.Reflection.RuntimeMethodInfo',
StackTrace: ' at Startup.<1.GetResult()\r\n at Startup.`
Source: 'cp2luegt',
HResult: -2146233088 },
HResult: -2146233088 }
name
The exception is copied back as Error object like every normal result object from the .NET world to JavaScript.
Therefore all properties and their values are available on the Error object.
Additionally, the following happens during the mapping:
* To represent the Exception type, its full name is stored as .
Message
* To follow the JavaScript convention for Errors, the is also stored as the property message.
System::Reflection::RuntimeMethodInfo
* s are not copied to avoid stack overflows
`
`
$>node sample.js
Edge.js:58
edge.callClrFunc(appId, data, callback);
^
System.Reflection.TargetInvocationException: Exception has been thrown by the target of an invocation.
---> System.Exception: Sample exception
at Startup.Invoke(Object input) in sample.cs:line 12
Task
JavaScript exceptions thrown in Node.js code invoked from .NET are wrapped in a CLR exception and cause the asynchronous