private void AddProperty(ObjectInstance instance, string name, DelegateWrapper delegateWrapper)
{
JsValue getter = JsValue.FromObject(_engine.JintEngine, delegateWrapper);
JsValue setter = JsValue.Null;
instance.DefineOwnProperty(name, new PropertyDescriptor(getter, setter, true, false), true);
}
public void ShouldWork()
{
var script = @"
function execute(doc, args)
{
var i = doc;
{
function doSomething() {
return ""ayende"";
}
i.Name = doSomething();
}
}
";
var engine = new Engine(options =>
{
options.Strict();
});
var args = new JsValue[1];
var user = new User();
args[0] = JsValue.FromObject(engine, user);
engine.Execute(script);
var call = engine.GetValue("execute").TryCast <ICallable>();
call.Call(Undefined.Instance, args);
Assert.Equal("ayende", user.Name);
}
public ClrProperty(global::Jint.Engine engine, DomConverter converter, PropertyInfo property)
{
Get =
property.GetMethod != null && property.GetMethod.IsPublic ? new ClrFunctionInstance(engine, (jsThis, values) =>
{
var clrThis = converter.ConvertFromJs(jsThis);
return(JsValue.FromObject(engine, property.GetValue(clrThis)));
}) : null;
var setter = new Lazy <Action <object, JsValue> >(() => CreateSetter(converter, property));
Set =
property.SetMethod != null && property.SetMethod.IsPublic ? new ClrFunctionInstance(engine, (jsThis, values) =>
{
try
{
var clrThis = converter.ConvertFromJs(jsThis);
if (values.Length == 0)
{
return(JsValue.Undefined);
}
setter.Value(clrThis, values[0]);
return(JsValue.Undefined);
}
catch (Exception e)
{
throw new JavaScriptException(e.Message);
}
}) : new ClrFunctionInstance(engine, (value, values) => JsValue.Undefined);
}
protected override ExpressionResult EvaluateInternal(EvaluationContext context)
{
var left = _left.GetValue(context).Value;
var right = _right.GetValue(context).Value;
if (context.OperatorOverloadingAllowed &&
TryOperatorOverloading(context, left, right, "op_Subtraction", out var opResult))
{
return(NormalCompletion(JsValue.FromObject(context.Engine, opResult)));
}
JsValue number;
left = TypeConverter.ToNumeric(left);
right = TypeConverter.ToNumeric(right);
if (AreIntegerOperands(left, right))
{
number = JsNumber.Create((long)left.AsInteger() - right.AsInteger());
}
else if (AreNonBigIntOperands(left, right))
{
number = JsNumber.Create(left.AsNumber() - right.AsNumber());
}
else
{
number = JsBigInt.Create(TypeConverter.ToBigInt(left) - TypeConverter.ToBigInt(right));
}
return(NormalCompletion(number));
}
protected override ExpressionResult EvaluateInternal(EvaluationContext context)
{
var left = _left.GetValue(context).Value;
var right = _right.GetValue(context).Value;
JsValue result;
if (context.OperatorOverloadingAllowed &&
TryOperatorOverloading(context, left, right, "op_Multiply", out var opResult))
{
result = JsValue.FromObject(context.Engine, opResult);
}
else if (AreIntegerOperands(left, right))
{
result = JsNumber.Create((long)left.AsInteger() * right.AsInteger());
}
else
{
var leftNumeric = TypeConverter.ToNumeric(left);
var rightNumeric = TypeConverter.ToNumeric(right);
if (leftNumeric.IsNumber() && rightNumeric.IsNumber())
{
result = JsNumber.Create(leftNumeric.AsNumber() * rightNumeric.AsNumber());
}
else
{
AssertValidBigIntArithmeticOperands(context, leftNumeric, rightNumeric);
result = JsBigInt.Create(leftNumeric.AsBigInt() * rightNumeric.AsBigInt());
}
}
return(NormalCompletion(result));
}
public bool TryConvert(Engine engine, object value, out JsValue result)
{
result = null;
if (value is Enum)
{
result = value.ToString();
return(true);
}
switch (value)
{
case IUser user:
result = JintUser.Create(engine, user);
return(true);
case ClaimsPrincipal principal:
result = JintUser.Create(engine, principal);
return(true);
case Instant instant:
result = JsValue.FromObject(engine, instant.ToDateTimeUtc());
return(true);
case Status status:
result = status.ToString();
return(true);
case NamedContentData content:
result = new ContentDataObject(engine, content);
return(true);
}
return(false);
}
private IEnumerable <KeyValuePair <string, PropertyDescriptor> > GetObjectProperties(ObjectWrapper objectWrapper)
{
var target = objectWrapper.Target;
if (target is IDictionary dictionary)
{
foreach (DictionaryEntry entry in dictionary)
{
var jsValue = JsValue.FromObject(_scriptEngine, entry.Value);
var descriptor = new PropertyDescriptor(jsValue, false, false, false);
yield return(new KeyValuePair <string, PropertyDescriptor>(entry.Key.ToString(), descriptor));
}
yield break;
}
var type = target.GetType();
if (target is Task task &&
task.IsCompleted == false)
{
foreach (var property in type.GetProperties(BindingFlags.Instance | BindingFlags.Public))
{
if (property.CanRead == false)
{
continue;
}
if (property.Name == nameof(Task <int> .Result))
{
var taskResultDescriptor = JintPreventResolvingTasksReferenceResolver.GetRunningTaskResult(task);
yield return(new KeyValuePair <string, PropertyDescriptor>(property.Name, taskResultDescriptor));
continue;
}
var descriptor = new PropertyInfoDescriptor(_scriptEngine, property, target);
yield return(new KeyValuePair <string, PropertyDescriptor>(property.Name, descriptor));
}
yield break;
}
// look for properties
foreach (var property in type.GetProperties(BindingFlags.Instance | BindingFlags.Public))
{
if (property.CanRead == false)
{
continue;
}
var descriptor = new PropertyInfoDescriptor(_scriptEngine, property, target);
yield return(new KeyValuePair <string, PropertyDescriptor>(property.Name, descriptor));
}
// look for fields
foreach (var field in type.GetFields(BindingFlags.Instance | BindingFlags.Public))
{
var descriptor = new FieldInfoDescriptor(_scriptEngine, field, target);
yield return(new KeyValuePair <string, PropertyDescriptor>(field.Name, descriptor));
}
}
private JsValue Json(object obj)
{
var engine = new Engine();
return(engine.Json.Parse(engine.Global,
new[] { JsValue.FromObject(engine, JsonConvert.SerializeObject(obj)), }));
}
public JsValue Compile(string sourceCode, string filePath)
{
var moduleObject = JsValue.FromObject(this.engine.engine, this);
// moduleObject.AsObject().DefineOwnProperty("exports", new Runtime.Descriptors.PropertyDescriptor() {
// Get = new ClrFunctionInstance(engine.engine, (thisObj, args) => Exports),
// Set = new ClrFunctionInstance(engine.engine, (thisObj, args) => Exports = args.At(0)),
// Enumerable = true,
// Configurable = true,
// }, throwOnError: true);
engine.engine.Execute($@"
;(function (module, exports, __dirname, require) {{
{sourceCode}
}})
").GetCompletionValue().As <FunctionInstance>().Call(
JsValue.FromObject(this.engine.engine, this),
new JsValue[] {
moduleObject,
this.Exports,
Path.GetDirectoryName(filePath),
new ClrFunctionInstance(this.engine.engine, filePath, (thisObj, arguments) => Require(arguments.At(0).AsString()))
// new DelegateWrapper(engine.engine, new Func<string, JsValue>(this.Require)),
}
);
return(Exports);
}
public void Test1()
{
var engine = new Engine();
engine.Execute("function add(a, b) { return a + b; }");
var v1 = engine.GetValue("add");
var v2 = engine.GetValue("non-existant");
_output.WriteLine($"{v1.Type}");
_output.WriteLine($"{v2.Type}");
var v3 = v1.Invoke(1, 2);
_output.WriteLine($"{v3.Type}");
_output.WriteLine($"{v3.AsNumber()}");
var v4 = JsValue.FromObject(engine, null);
_output.WriteLine($"{v4.Type}");
var js_obj_raw = new TestObj1()
{
Id = 10, Content = "Hello!"
};
var v5 = JsValue.FromObject(engine, js_obj_raw);
_output.WriteLine($"{v5.Type}");
var v6 = v5.AsObject().Get(JsValue.FromObject(engine, "content"));
_output.WriteLine($"{v6.Type}");
_output.WriteLine($"{v6.AsString()}");
}
/// <inheritDoc />
public object Invoke(params object[] args)
{
var jsThis = _binding == null ? JsValue.Null : _binding;
var argsLength = args?.Length ?? 0;
var jsArgs = new JsValue[argsLength];
for (int i = 0; i < argsLength; ++i)
{
jsArgs[i] = JsValue.FromObject(_context.Engine, args[i]);
}
try
{
var result = _callback(jsThis, jsArgs);
return(result.ToObject());
}
catch (JavaScriptException jsError)
{
Log.Warning("Scripting", "[{0}:{1}] {2}", jsError.Location.Source, jsError.LineNumber, jsError.Message);
ExecutionError = jsError;
}
catch (Exception exception)
{
// TODO: Most recent js stack trace?
Log.Warning("Scripting", "An unknown error has occured: {0}", exception);
ExecutionError = exception;
}
return(null);
}
public void ExecuteModule(string entryPointModuleIdentifier)
{
var sourceCode = resourceLoader.Load(new Uri("resm:RaisingStudio.NativeScript.require.js"));
var requireFunction = this.Execute(sourceCode, "require.js").GetCompletionValue();
var require = requireFunction.Invoke(this.applicationPath, JsValue.FromObject(this, new Func <string, string, object>(this.CreateModuleFunction)));
require.Invoke("./");
}
private CliApiBuilder AddProperty(string name, DelegateWrapper delegateWrapper)
{
JsValue getter = JsValue.FromObject(_engine, delegateWrapper);
JsValue setter = JsValue.Null;
_instance.DefineOwnProperty(name, new PropertyDescriptor(getter, setter, true, false), true);
return(this);
}
/// <summary>
/// Loads this plugin
/// </summary>
public void Load()
{
// Load the plugin
string code = File.ReadAllText(Filename);
Name = Path.GetFileNameWithoutExtension(Filename);
JavaScriptEngine.Execute(code);
if (JavaScriptEngine.GetValue(Name).TryCast <ObjectInstance>() == null)
{
throw new Exception("Plugin is missing main object");
}
Class = JavaScriptEngine.GetValue(Name).AsObject();
if (!Class.HasProperty("Name"))
{
Class.FastAddProperty("Name", Name, true, false, true);
}
else
{
Class.Put("Name", Name, true);
}
// Read plugin attributes
if (!Class.HasProperty("Title") || string.IsNullOrEmpty(Class.Get("Title").AsString()))
{
throw new Exception("Plugin is missing title");
}
if (!Class.HasProperty("Author") || string.IsNullOrEmpty(Class.Get("Author").AsString()))
{
throw new Exception("Plugin is missing author");
}
if (!Class.HasProperty("Version") || Class.Get("Version").ToObject() == null)
{
throw new Exception("Plugin is missing version");
}
Title = Class.Get("Title").AsString();
Author = Class.Get("Author").AsString();
Version = (VersionNumber)Class.Get("Version").ToObject();
HasConfig = Class.HasProperty("HasConfig") && Class.Get("HasConfig").AsBoolean();
// Set attributes
Class.FastAddProperty("Plugin", JsValue.FromObject(JavaScriptEngine, this), true, false, true);
Globals = new List <string>();
foreach (var property in Class.Properties)
{
if (property.Value.Value != null)
{
var callable = property.Value.Value.Value.TryCast <ICallable>();
if (callable != null)
{
Globals.Add(property.Key);
}
}
}
// Bind any base methods (we do it here because we don't want them to be hooked)
BindBaseMethods();
}
public JsValue readJson(String path)
{
using (var reader = new StreamReader(formatPath(path)))
{
return(eng.Json.Parse(eng.Json, new JsValue[] {
JsValue.FromObject(eng, reader.ReadToEnd( ))
}));
}
}
/// <inheritDoc />
public void Bind(object @this)
{
if (null != _binding)
{
return;
}
_binding = JsValue.FromObject(_context.Engine, @this);
}
public JsValue EvaluateLiteral(Literal literal)
{
if (literal.Type == SyntaxNodes.RegularExpressionLiteral)
{
return(_engine.RegExp.Construct(literal.Raw));
}
return(JsValue.FromObject(_engine, literal.Value));
}
public JsValue getString(String URL)
{
using (var client = new WebClient( ))
{
client.Headers.Set("user-agent", UA);
return(JsValue.FromObject(eng, client.DownloadString(URL)));
}
}
public ObjectInstance Construct(JsValue[] arguments)
{
if (arguments.Length == 0 &&
#if NETPORTABLE
Type.IsValueType)
#else
Type.IsValueType())
#endif
{
var instance = Activator.CreateInstance(Type);
var result = TypeConverter.ToObject(Engine, JsValue.FromObject(Engine, instance));
return(result);
}
var constructors = Type.GetConstructors(BindingFlags.Public | BindingFlags.Instance);
var methods = TypeConverter.FindBestMatch(Engine, constructors, arguments).ToList();
foreach (var method in methods)
{
var parameters = new object[arguments.Length];
try
{
for (var i = 0; i < arguments.Length; i++)
{
var parameterType = method.GetParameters()[i].ParameterType;
if (parameterType == typeof(JsValue))
{
parameters[i] = arguments[i];
}
else
{
parameters[i] = Engine.ClrTypeConverter.Convert(
arguments[i].ToObject(),
parameterType,
CultureInfo.InvariantCulture);
}
}
var constructor = (ConstructorInfo)method;
var instance = constructor.Invoke(parameters.ToArray());
var result = TypeConverter.ToObject(Engine, JsValue.FromObject(Engine, instance));
// todo: cache method info
return(result);
}
catch
{
// ignore method
}
}
throw new JavaScriptException(Engine.TypeError, "No public methods with the specified arguments were found.");
}
private void CustomResultHandler(MulticastDelegate resultHander, KApiResponse response)
{
var func = resultHander.Target as ScriptFunctionInstance;
var result = func.Call(func, new[] { JsValue.FromObject(func.Engine, response.Code), JsValue.FromObject(func.Engine, response.Data) }).ToObject();
if (result != null)
{
_renderContext.Response.AppendString(Helpers.ToJson(result));
}
}
public static Jint.Native.Array.ArrayInstance ToJavaScriptArray(List <object> values, Jint.Engine engine)
{
var jsValues = new List <JsValue>();
foreach (var v in values)
{
jsValues.Add(JsValue.FromObject(engine, v));
}
return((ArrayInstance)engine.Array.Construct(jsValues.ToArray()));
}
public void Restore(String refer, Object args)
{
var func = GetFunc(refer, "Restore");
if (func == null)
{
return;
}
func(JsValue.Undefined, new JsValue[] { JsValue.FromObject(_engine, args) });
}
void SetArguments(Object args)
{
var func = GetFunc(_root.Id, "Arguments");
if (func == null)
{
throw new WorkflowException($"Script element {_root.Id}.Arguments not found");
}
func(JsValue.Undefined, new JsValue[] { JsValue.FromObject(_engine, args) });
}
/// <summary>
/// Called when it's time to call a hook
/// </summary>
/// <param name="hookname"></param>
/// <param name="args"></param>
/// <returns></returns>
protected override object OnCallHook(string hookname, object[] args)
{
ICallable callable;
if (!Globals.TryGetValue(hookname, out callable))
{
return(null);
}
return(callable.Call(Class, args != null ? args.Select(x => JsValue.FromObject(JavaScriptEngine, x)).ToArray() : new JsValue[] {}).ToObject());
}
/// <summary>
/// Calls a function by the given name and returns the output
/// </summary>
/// <param name="name"></param>
/// <param name="args"></param>
/// <returns></returns>
private object CallFunction(string name, object[] args)
{
var callable = Class.Get(name).TryCast <ICallable>();
if (!Globals.Contains(name) || !Class.HasProperty(name) || callable == null)
{
return(null);
}
return(callable.Call(Class, args != null ? args.Select(x => JsValue.FromObject(JavaScriptEngine, x)).ToArray() : new JsValue[] {}));
}
public JsValue getJson(String URL)
{
using (var client = new WebClient( ))
{
client.Headers.Set("user-agent", UA);
var str = client.DownloadString(URL);
return(eng.Json.Parse(eng.Json, new JsValue[] { JsValue.FromObject(eng, str) }));
}
}
private JsValue ConstructValues(List <BlittableJsonReaderObject> values)
{
var items = new PropertyDescriptor[values.Count];
for (int j = 0; j < values.Count; j++)
{
var val = values[j];
if (JavaScriptIndexUtils.GetValue(Engine, val, out JsValue jsValue, true) == false)
{
continue;
}
items[j] = new PropertyDescriptor(jsValue, true, true, true);
}
var jsArray = new ArrayInstance(Engine, items);
jsArray.Prototype = Engine.Array.PrototypeObject;
jsArray.Extensible = false;
var result = new ObjectInstance(Engine)
{
Extensible = true
};
result.Put("values", jsArray, false);
if (_singleField)
{
var index = values[0].GetPropertyIndex(_groupByFields[0]);
if (index != -1)
{
BlittableJsonReaderObject.PropertyDetails prop = default;
values[0].GetPropertyByIndex(index, ref prop, addObjectToCache: false);
result.Put("key", JsValue.FromObject(Engine, prop.Value), false);
}
}
else
{
var key = new ObjectInstance(Engine)
{
Extensible = true
};
result.Put("key", key, false);
for (int i = 0; i < _groupByFields.Length; i++)
{
var index = values[0].GetPropertyIndex(_groupByFields[i]);
if (index != -1)
{
BlittableJsonReaderObject.PropertyDetails prop = default;
values[0].GetPropertyByIndex(index, ref prop, addObjectToCache: false);
key.Put(_groupByFields[i], JsValue.FromObject(Engine, prop.Value), false);
}
}
}
return(result);
}
public ObjectInstance Construct(JsValue[] arguments)
{
var constructors = Type.GetConstructors(BindingFlags.Public | BindingFlags.Instance);
var methods = TypeConverter.FindBestMatch(Engine, constructors, arguments).ToList();
var parameters = new object[arguments.Length];
foreach (var method in methods)
{
try
{
for (var i = 0; i < arguments.Length; i++)
{
var parameterType = method.GetParameters()[i].ParameterType;
if (parameterType == typeof(JsValue))
{
parameters[i] = arguments[i];
}
else
{
parameters[i] = Engine.ClrTypeConverter.Convert(
arguments[i].ToObject(),
parameterType,
CultureInfo.InvariantCulture);
}
}
var constructor = (ConstructorInfo)method;
var result = TypeConverter.ToObject(Engine, JsValue.FromObject(Engine, constructor.Invoke(parameters.ToArray())));
// todo: cache method info
return(result);
}
catch
{
// ignore method
}
}
StringBuilder argumentLog = new StringBuilder(arguments.Length);
for (int i = 0, len = arguments.Length; i < len; i++)
{
argumentLog.AppendLine(arguments[i].ToString());
}
throw new JavaScriptException(
Engine.TypeError,
string.Format("No public constructors with the specified arguments found on {0}:\n{1}",
Type.Name,
argumentLog));
}
private async Task GetReferencesAsync(ScriptExecutionContext context, DomainId appId, ClaimsPrincipal user, JsValue references, Action <JsValue> callback)
{
Guard.NotNull(callback, nameof(callback));
var ids = new List <DomainId>();
if (references.IsString())
{
ids.Add(DomainId.Create(references.ToString()));
}
else if (references.IsArray())
{
foreach (var value in references.AsArray())
{
if (value.IsString())
{
ids.Add(DomainId.Create(value.ToString()));
}
}
}
if (ids.Count == 0)
{
var emptyContents = Array.Empty <IEnrichedContentEntity>();
callback(JsValue.FromObject(context.Engine, emptyContents));
return;
}
context.MarkAsync();
try
{
var app = await GetAppAsync(appId);
var requestContext =
new Context(user, app).Clone(b => b
.WithoutContentEnrichment()
.WithUnpublished()
.WithoutTotal());
var contentQuery = serviceProvider.GetRequiredService <IContentQueryService>();
var contents = await contentQuery.QueryAsync(requestContext, Q.Empty.WithIds(ids), context.CancellationToken);
// Reset the time contraints and other constraints so that our awaiting does not count as script time.
context.Engine.ResetConstraints();
callback(JsValue.FromObject(context.Engine, contents.ToArray()));
}
catch (Exception ex)
{
context.Fail(ex);
}
}
/// <summary>
/// Invoke the current value as function.
/// </summary>
/// <param name="value">The function to call.</param>
/// <param name="thisObj">The this value inside the function call.</param>
/// <param name="arguments">The arguments of the function call.</param>
/// <returns>The value returned by the function call.</returns>
public JsValue Invoke(JsValue value, object thisObj, object[] arguments)
{
var callable = value.TryCast <ICallable>();
if (callable == null)
{
throw new ArgumentException("Can only invoke functions");
}
return(callable.Call(JsValue.FromObject(this, thisObj), arguments.Select(x => JsValue.FromObject(this, x)).ToArray()));
}