@adapt-toolkit/sdk-native 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (17) hide show
  1. package/adapt_js.cc +915 -0
  2. package/adapt_js.h +128 -0
  3. package/addon.cc +11 -0
  4. package/binding.gyp +67 -0
  5. package/dist/adapt.d.ts +135 -0
  6. package/dist/adapt.d.ts.map +1 -0
  7. package/dist/adapt.js +371 -0
  8. package/dist/adapt.js.map +1 -0
  9. package/dist/addon_types.d.ts +63 -0
  10. package/dist/addon_types.d.ts.map +1 -0
  11. package/dist/addon_types.js +2 -0
  12. package/dist/addon_types.js.map +1 -0
  13. package/dist/index.d.ts +11 -0
  14. package/dist/index.d.ts.map +1 -0
  15. package/dist/index.js +15 -0
  16. package/dist/index.js.map +1 -0
  17. package/package.json +43 -0
package/adapt_js.cc ADDED
@@ -0,0 +1,915 @@
1
+ #include "adapt_js.h"
2
+ #include "js_native_api_types.h"
3
+ #include "napi.h"
4
+ #include <iostream>
5
+ #include <sstream>
6
+
7
+ bool AdaptEnvironment::initialized = false;
8
+
9
+ #define ADAPT_NAPI_THROW( kind, error ) \
10
+ do \
11
+ { \
12
+ std::cerr << error << std::endl; \
13
+ Napi::kind::New( info.Env(), error ).ThrowAsJavaScriptException(); \
14
+ return info.Env().Undefined(); \
15
+ } while( 0 )
16
+
17
+ #define CHECK_ENV \
18
+ if( !AW_Environment::isInitialized() ) \
19
+ { \
20
+ Napi::Error::New( info.Env(), "Adapt environment not initialized" ); \
21
+ }
22
+
23
+ #define ADAPT_EXPECT_ARG( kind, n ) \
24
+ CHECK_ENV \
25
+ if( !info[n].Is##kind() ) \
26
+ { \
27
+ Napi::TypeError::New( info.Env(), "Expected " #kind " value at position " #n ).ThrowAsJavaScriptException(); \
28
+ return info.Env().Undefined(); \
29
+ }
30
+
31
+ #define ADAPT_EXPECT_ARGC( n ) \
32
+ CHECK_ENV \
33
+ if( info.Length() != ( n ) ) \
34
+ { \
35
+ Napi::TypeError::New( info.Env(), "Expected " #n " arguments" ).ThrowAsJavaScriptException(); \
36
+ return info.Env().Undefined(); \
37
+ }
38
+
39
+ #define ADAPT_EXPECT_ARG_BOOLEAN( n ) ADAPT_EXPECT_ARG( Boolean, n )
40
+ #define ADAPT_EXPECT_ARG_STRING( n ) ADAPT_EXPECT_ARG( String, n )
41
+ #define ADAPT_EXPECT_ARG_NUMBER( n ) ADAPT_EXPECT_ARG( Number, n )
42
+ #define ADAPT_EXPECT_ARG_BUFFER( n ) ADAPT_EXPECT_ARG( Buffer, n )
43
+
44
+ #define ADAPT_EXPECT_OBJECT( arg, value, packet, indicator ) \
45
+ CHECK_ENV \
46
+ do \
47
+ { \
48
+ AdaptValue* __arg = nullptr; \
49
+ try \
50
+ { \
51
+ __arg = AdaptValue::Unwrap( ( value ).ToObject() ); \
52
+ } \
53
+ catch( ... ) \
54
+ { \
55
+ } \
56
+ \
57
+ if( __arg == nullptr ) \
58
+ { \
59
+ if( ( value ).IsString() ) \
60
+ { \
61
+ arg.ResetFromString( ( value ).As<Napi::String>(), packet ); \
62
+ } \
63
+ else if( ( value ).IsNumber() ) \
64
+ { \
65
+ arg.ResetFromNumber( ( value ).As<Napi::Number>(), packet ); \
66
+ } \
67
+ else if( ( value ).IsBoolean() ) \
68
+ { \
69
+ arg.ResetFromBoolean( ( value ).As<Napi::Boolean>(), packet ); \
70
+ } \
71
+ else \
72
+ { \
73
+ ADAPT_NAPI_THROW( TypeError, ( std::string( "Expected ADAPT object for " ) + indicator ).c_str() ); \
74
+ } \
75
+ } \
76
+ else \
77
+ { \
78
+ arg.m_value.reset_ptr( __arg->m_value.m_value ); \
79
+ arg.m_packet.reset_ptr( packet ); \
80
+ } \
81
+ } while( 0 );
82
+
83
+ #define ADAPT_EXPECT_ARG_EVALUATION_UNIT( name, i ) \
84
+ CHECK_ENV \
85
+ do \
86
+ { \
87
+ AdaptEvaluationUnit* __arg = nullptr; \
88
+ try \
89
+ { \
90
+ __arg = AdaptEvaluationUnit::Unwrap( ( info[i] ).ToObject() ); \
91
+ } \
92
+ catch( ... ) \
93
+ { \
94
+ } \
95
+ \
96
+ if( __arg == nullptr ) \
97
+ { \
98
+ ADAPT_NAPI_THROW( TypeError, ( std::string( "Expected ADAPT evaluation unit for arg " #i ) ).c_str() ); \
99
+ } \
100
+ else \
101
+ { \
102
+ if( __arg->m_unit.m_hashCode.isNull() ) \
103
+ ADAPT_NAPI_THROW( Error, "ADAPT evaluation unit is not initialized, did you use a default constructor or missed an earlier error?" ); \
104
+ name.m_hashCode.reset_ptr( __arg->m_unit.m_hashCode ); \
105
+ } \
106
+ } while( 0 );
107
+
108
+ #define ADAPT_RETURN_EVALUATION_UNIT( from ) \
109
+ do \
110
+ { \
111
+ auto instance = AdaptEvaluationUnit::constructor->New( {} ); \
112
+ auto value = AdaptEvaluationUnit::Unwrap( instance ); \
113
+ value->m_unit.m_hashCode.move( ( from ).m_hashCode ); \
114
+ return instance; \
115
+ } while( 0 )
116
+
117
+ #define ADAPT_RETURN_PACKET( from ) \
118
+ do \
119
+ { \
120
+ auto instance = AdaptPacketContext::constructor->New( {} ); \
121
+ auto value = AdaptPacketContext::Unwrap( instance ); \
122
+ value->m_packet.m_packet.move( ( from ).m_packet ); \
123
+ return instance; \
124
+ } while( 0 )
125
+
126
+ #define ADAPT_RETURN_VALUE( from_value, from_packet ) \
127
+ auto instance = AdaptValue::constructor->New( {} ); \
128
+ auto value = AdaptValue::Unwrap( instance ); \
129
+ value->m_value.m_value.move( from_value.m_value ); \
130
+ value->m_value.m_packet.reset_ptr( from_packet.m_packet ); \
131
+ return instance;
132
+
133
+ #define ADAPT_RETURN_UNDEFINED \
134
+ return info.Env().Undefined();
135
+
136
+ #define ERROR_CHECK( msg ) \
137
+ if( !msg.empty() ) \
138
+ { \
139
+ throw Napi::Error::New( info.Env(), ( msg ).c_str() ); \
140
+ return info.Env().Undefined(); \
141
+ }
142
+
143
+ #define CONSTRUCTOR_ERROR( msg ) \
144
+ do \
145
+ { \
146
+ Napi::Error::New( info.Env(), msg ).ThrowAsJavaScriptException(); \
147
+ } while( 0 )
148
+
149
+ Napi::FunctionReference* AdaptEvaluationUnit::constructor;
150
+
151
+ Napi::Object AdaptEvaluationUnit::NewInstance( Napi::Env env, Napi::Value arg )
152
+ {
153
+ Napi::EscapableHandleScope scope( env );
154
+ Napi::Object obj = env.GetInstanceData<Napi::FunctionReference>()->New( { arg } );
155
+ return scope.Escape( napi_value( obj ) ).ToObject();
156
+ }
157
+
158
+ Napi::Object AdaptEvaluationUnit::Init( Napi::Env env, Napi::Object exports )
159
+ {
160
+ Napi::Function func = DefineClass( env,
161
+ "AdaptEvaluationUnit",
162
+ { InstanceMethod( "Destroy", &AdaptEvaluationUnit::Destroy ),
163
+ InstanceMethod( "Clone", &AdaptEvaluationUnit::Clone ),
164
+ StaticMethod( "LoadFromFile", &AdaptEvaluationUnit::LoadFromFile ),
165
+ StaticMethod( "LoadFromContents", &AdaptEvaluationUnit::LoadFromContents ) } );
166
+
167
+ constructor = new Napi::FunctionReference();
168
+ *constructor = Napi::Persistent( func );
169
+ constructor->SuppressDestruct();
170
+
171
+ env.SetInstanceData( constructor );
172
+
173
+ exports.Set( "AdaptEvaluationUnit", func );
174
+ return exports;
175
+ }
176
+
177
+ Napi::Value AdaptEvaluationUnit::Destroy( const Napi::CallbackInfo& info )
178
+ {
179
+ ADAPT_EXPECT_ARGC( 0 );
180
+
181
+ m_unit.Destroy();
182
+
183
+ ADAPT_RETURN_UNDEFINED;
184
+ }
185
+
186
+ Napi::Value AdaptEvaluationUnit::Clone( const Napi::CallbackInfo& info )
187
+ {
188
+ ADAPT_EXPECT_ARGC( 0 );
189
+
190
+ AW_EvaluationUnit result;
191
+ std::string msg = m_unit.Clone( result );
192
+ ERROR_CHECK( msg );
193
+
194
+ ADAPT_RETURN_EVALUATION_UNIT( result );
195
+ }
196
+
197
+ AdaptEvaluationUnit::AdaptEvaluationUnit( const Napi::CallbackInfo& info )
198
+ : Napi::ObjectWrap<AdaptEvaluationUnit>( info )
199
+ {
200
+ }
201
+
202
+ Napi::Value AdaptEvaluationUnit::LoadFromFile( const Napi::CallbackInfo& info )
203
+ {
204
+ ADAPT_EXPECT_ARGC( 1 );
205
+ ADAPT_EXPECT_ARG_STRING( 0 );
206
+
207
+ AW_EvaluationUnit ret;
208
+ std::string msg = AW_EvaluationUnit::LoadFromFile( ret, info[0].ToString() );
209
+ ERROR_CHECK( msg );
210
+
211
+ ADAPT_RETURN_EVALUATION_UNIT( ret );
212
+ }
213
+
214
+ Napi::Value AdaptEvaluationUnit::LoadFromContents( const Napi::CallbackInfo& info )
215
+ {
216
+ ADAPT_EXPECT_ARGC( 1 );
217
+ ADAPT_EXPECT_ARG_BUFFER( 0 );
218
+ auto buffer = info[0].As<Napi::Buffer<unsigned char>>();
219
+ auto data = buffer.Data();
220
+ auto size = buffer.Length();
221
+
222
+ AW_EvaluationUnit ret;
223
+ std::string msg = AW_EvaluationUnit::LoadFromContents( ret, data, size );
224
+ ERROR_CHECK( msg );
225
+
226
+ ADAPT_RETURN_EVALUATION_UNIT( ret );
227
+ }
228
+
229
+ Napi::Object AdaptEnvironment::Init( Napi::Env env, Napi::Object exports )
230
+ {
231
+ exports.Set( Napi::String::New( env, "Initialize" ),
232
+ Napi::Function::New( env, &AdaptEnvironment::InitializeEnvironment ) );
233
+
234
+ exports.Set( Napi::String::New( env, "EmptyPacket" ), Napi::Function::New( env, &AdaptEnvironment::EmptyPacket ) );
235
+ exports.Set( Napi::String::New( env, "CreatePacket" ), Napi::Function::New( env, &AdaptEnvironment::CreatePacket ) );
236
+ exports.Set( Napi::String::New( env, "IsAdaptValue" ), Napi::Function::New( env, &AdaptEnvironment::IsAdaptValue ) );
237
+ exports.Set( Napi::String::New( env, "IsAdaptPacketContext" ), Napi::Function::New( env, &AdaptEnvironment::IsAdaptPacket ) );
238
+ exports.Set( Napi::String::New( env, "IsAdaptEvaluationUnit" ), Napi::Function::New( env, &AdaptEnvironment::IsAdaptEvaluationUnit ) );
239
+ exports.Set( Napi::String::New( env, "SystemTime" ), Napi::Function::New( env, &AdaptEnvironment::SystemTime ) );
240
+ exports.Set( Napi::String::New( env, "ParseTime" ), Napi::Function::New( env, &AdaptEnvironment::ParseTime ) );
241
+ exports.Set( Napi::String::New( env, "GetRandomBytes" ), Napi::Function::New( env, &AdaptEnvironment::GetRandomBytes ) );
242
+ exports.Set( Napi::String::New( env, "GetStderrContents" ), Napi::Function::New( env, &AdaptEnvironment::GetStderrContents ) );
243
+ exports.Set( Napi::String::New( env, "GetStdoutContents" ), Napi::Function::New( env, &AdaptEnvironment::GetStdoutContents ) );
244
+
245
+ return exports;
246
+ }
247
+
248
+ static std::stringstream error_output;
249
+ static std::stringstream print_output;
250
+
251
+ Napi::Value AdaptEnvironment::GetStderrContents( const Napi::CallbackInfo& info )
252
+ {
253
+ ADAPT_EXPECT_ARGC( 0 );
254
+ static std::string contents;
255
+ contents = error_output.str();
256
+ error_output.str( "" );
257
+ error_output.clear();
258
+ return Napi::String::New( info.Env(), contents.c_str() );
259
+ }
260
+
261
+ Napi::Value AdaptEnvironment::GetStdoutContents( const Napi::CallbackInfo& info )
262
+ {
263
+ ADAPT_EXPECT_ARGC( 0 );
264
+ static std::string contents;
265
+ contents = print_output.str();
266
+ print_output.str( "" );
267
+ print_output.clear();
268
+ return Napi::String::New( info.Env(), contents.c_str() );
269
+ }
270
+
271
+ Napi::Value AdaptEnvironment::InitializeEnvironment( const Napi::CallbackInfo& info )
272
+ {
273
+ ADAPT_EXPECT_ARGC( 1 );
274
+ ADAPT_EXPECT_ARG_BOOLEAN( 0 );
275
+
276
+ bool test_mode = info[0].As<Napi::Boolean>();
277
+ std::cerr.rdbuf( error_output.rdbuf() );
278
+ std::cout.rdbuf( print_output.rdbuf() );
279
+
280
+ return Napi::Boolean::New( info.Env(), AW_Environment::init( test_mode ) );
281
+ }
282
+
283
+ Napi::Value AdaptEnvironment::IsAdaptValue( const Napi::CallbackInfo& info )
284
+ {
285
+ ADAPT_EXPECT_ARGC( 1 );
286
+ AdaptValue* __arg = nullptr;
287
+ try
288
+ {
289
+ __arg = AdaptValue::Unwrap( info[0].ToObject() );
290
+ }
291
+ catch( ... )
292
+ {
293
+ }
294
+
295
+ return Napi::Boolean::New( info.Env(), __arg != nullptr );
296
+ }
297
+
298
+ Napi::Value AdaptEnvironment::IsAdaptPacket( const Napi::CallbackInfo& info )
299
+ {
300
+ ADAPT_EXPECT_ARGC( 1 );
301
+ AdaptPacketContext* __arg = nullptr;
302
+ try
303
+ {
304
+ __arg = AdaptPacketContext::Unwrap( info[0].ToObject() );
305
+ }
306
+ catch( ... )
307
+ {
308
+ }
309
+
310
+ return Napi::Boolean::New( info.Env(), __arg != nullptr );
311
+ }
312
+
313
+ Napi::Value AdaptEnvironment::IsAdaptEvaluationUnit( const Napi::CallbackInfo& info )
314
+ {
315
+ ADAPT_EXPECT_ARGC( 1 );
316
+ AdaptEvaluationUnit* __arg = nullptr;
317
+ try
318
+ {
319
+ __arg = AdaptEvaluationUnit::Unwrap( info[0].ToObject() );
320
+ }
321
+ catch( ... )
322
+ {
323
+ }
324
+
325
+ return Napi::Boolean::New( info.Env(), __arg != nullptr );
326
+ }
327
+
328
+ Napi::Value AdaptEnvironment::CreatePacket( const Napi::CallbackInfo& info )
329
+ {
330
+ AW_PacketContext packet;
331
+ ADAPT_EXPECT_ARGC( 6 );
332
+ AW_EvaluationUnit evalUnit;
333
+ ADAPT_EXPECT_ARG_EVALUATION_UNIT( evalUnit, 0 );
334
+ ADAPT_EXPECT_ARG_STRING( 1 );
335
+ ADAPT_EXPECT_ARG_STRING( 2 );
336
+ AW_Value __timestamp;
337
+ ADAPT_EXPECT_OBJECT( __timestamp, info[3], packet.m_packet, "argument 4 of AdaptPacketContext::CreatePacket" );
338
+ ADAPT_EXPECT_ARG_BOOLEAN( 4 );
339
+ AW_Value init_arg;
340
+ ADAPT_EXPECT_OBJECT( init_arg, info[5], packet.m_packet, "argument 6 of AdaptPacketContext::CreatePacket" )
341
+
342
+ std::string msg = AW_Environment::instance()->CreatePacket( packet, evalUnit, info[1].ToString(), info[2].ToString(), __timestamp, info[4].ToBoolean(), init_arg );
343
+ ERROR_CHECK( msg );
344
+ ADAPT_RETURN_PACKET( packet );
345
+ }
346
+
347
+ Napi::Value AdaptEnvironment::EmptyPacket( const Napi::CallbackInfo& info )
348
+ {
349
+ AW_PacketContext packet;
350
+
351
+ ADAPT_EXPECT_ARGC( 1 );
352
+ ADAPT_EXPECT_ARG_BOOLEAN( 0 );
353
+
354
+ std::string msg = AW_Environment::instance()->EmptyPacket( packet, info[0].ToBoolean() );
355
+ ERROR_CHECK( msg );
356
+ ADAPT_RETURN_PACKET( packet );
357
+ }
358
+
359
+ Napi::Value AdaptEnvironment::SystemTime( const Napi::CallbackInfo& info )
360
+ {
361
+ ADAPT_EXPECT_ARGC( 0 );
362
+ AW_Value ret;
363
+ std::string msg = AW_Environment::instance()->SystemTime( ret );
364
+ ERROR_CHECK( msg );
365
+ ADAPT_RETURN_VALUE( ret, ret );
366
+ }
367
+
368
+ Napi::Value AdaptEnvironment::ParseTime( const Napi::CallbackInfo& info )
369
+ {
370
+ ADAPT_EXPECT_ARGC( 1 );
371
+ ADAPT_EXPECT_ARG_STRING( 0 );
372
+ AW_Value ret;
373
+ std::string msg = AW_Environment::instance()->ParseTime( ret, info[0].ToString() );
374
+ ERROR_CHECK( msg );
375
+ ADAPT_RETURN_VALUE( ret, ret );
376
+ }
377
+
378
+ Napi::Value AdaptEnvironment::GetRandomBytes( const Napi::CallbackInfo& info )
379
+ {
380
+ ADAPT_EXPECT_ARGC( 1 );
381
+ ADAPT_EXPECT_ARG_NUMBER( 0 );
382
+ AW_Value ret;
383
+ auto length = info[0].ToNumber();
384
+ std::string msg = AW_Environment::instance()->GetRandomBytes( ret, length );
385
+ ERROR_CHECK( msg );
386
+ ADAPT_RETURN_VALUE( ret, ret );
387
+ }
388
+
389
+ // TODO: Can this be called from JS?
390
+ AdaptPacketContext::AdaptPacketContext( const Napi::CallbackInfo& info )
391
+ : Napi::ObjectWrap<AdaptPacketContext>( info )
392
+ {
393
+ }
394
+
395
+ Napi::FunctionReference* AdaptPacketContext::constructor;
396
+
397
+ Napi::Object AdaptPacketContext::Init( Napi::Env env, Napi::Object exports )
398
+ {
399
+ Napi::Function func = DefineClass( env,
400
+ "AdaptPacketContext",
401
+ { InstanceMethod( "Destroy", &AdaptPacketContext::Destroy ),
402
+ InstanceMethod( "ParseValue", &AdaptPacketContext::ParseValue ),
403
+ InstanceMethod( "ParseValueFromJSON", &AdaptPacketContext::ParseValueFromJSON ),
404
+ InstanceMethod( "CreateDictionary", &AdaptPacketContext::CreateDictionary ),
405
+ InstanceMethod( "NewBinaryFromHex", &AdaptPacketContext::NewBinaryFromHex ),
406
+ InstanceMethod( "NewBinaryFromBuffer", &AdaptPacketContext::NewBinaryFromBuffer ),
407
+ InstanceMethod( "ExecuteTransaction", &AdaptPacketContext::ExecuteTransaction ),
408
+ InstanceMethod( "ExecuteFunction", &AdaptPacketContext::ExecuteFunction ),
409
+ InstanceMethod( "GetHash", &AdaptPacketContext::GetHash ),
410
+ InstanceMethod( "GetContainerID", &AdaptPacketContext::GetContainerID ),
411
+ InstanceMethod( "GetCodeID", &AdaptPacketContext::GetCodeID ),
412
+ InstanceMethod( "Serialize", &AdaptPacketContext::Serialize ),
413
+ InstanceMethod( "Clone", &AdaptPacketContext::Clone ),
414
+ InstanceMethod( "TransactionsList", &AdaptPacketContext::TransactionsList ),
415
+ InstanceMethod( "NilObject", &AdaptPacketContext::NilObject ),
416
+ StaticMethod( "LoadFromFile", &AdaptPacketContext::LoadFromFile ),
417
+ StaticMethod( "LoadFromContents", &AdaptPacketContext::LoadFromContents ) } );
418
+
419
+ constructor = new Napi::FunctionReference();
420
+ *constructor = Napi::Persistent( func );
421
+ constructor->SuppressDestruct();
422
+
423
+ env.SetInstanceData( constructor );
424
+
425
+ exports.Set( "AdaptPacketContext", func );
426
+ return exports;
427
+ }
428
+
429
+ Napi::Value AdaptPacketContext::Destroy( const Napi::CallbackInfo& info )
430
+ {
431
+ ADAPT_EXPECT_ARGC( 0 );
432
+
433
+ m_packet.Destroy();
434
+
435
+ ADAPT_RETURN_UNDEFINED;
436
+ }
437
+
438
+ Napi::Value AdaptPacketContext::Clone( const Napi::CallbackInfo& info )
439
+ {
440
+ ADAPT_EXPECT_ARGC( 0 );
441
+
442
+ AW_PacketContext result;
443
+ std::string msg = m_packet.Clone( result );
444
+ ERROR_CHECK( msg );
445
+
446
+ ADAPT_RETURN_PACKET( result );
447
+ }
448
+
449
+ Napi::Value AdaptPacketContext::LoadFromFile( const Napi::CallbackInfo& info )
450
+ {
451
+ ADAPT_EXPECT_ARGC( 1 );
452
+ ADAPT_EXPECT_ARG_STRING( 0 );
453
+ AW_PacketContext result;
454
+
455
+ std::string msg = AW_PacketContext::LoadFromFile( result, info[0].ToString() );
456
+ ERROR_CHECK( msg );
457
+
458
+ ADAPT_RETURN_PACKET( result );
459
+ }
460
+
461
+ Napi::Value AdaptPacketContext::LoadFromContents( const Napi::CallbackInfo& info )
462
+ {
463
+ ADAPT_EXPECT_ARGC( 1 );
464
+ auto buffer = info[0].As<Napi::Buffer<unsigned char>>();
465
+ auto data = buffer.Data();
466
+ auto length = buffer.Length();
467
+
468
+ AW_PacketContext result;
469
+ auto msg = AW_PacketContext::LoadFromContents( result, data, length );
470
+ ERROR_CHECK( msg );
471
+
472
+ ADAPT_RETURN_PACKET( result );
473
+ }
474
+
475
+ Napi::Value AdaptPacketContext::ParseValue( const Napi::CallbackInfo& info )
476
+ {
477
+ ADAPT_EXPECT_ARGC( 1 );
478
+ AW_Value arg;
479
+ ADAPT_EXPECT_OBJECT( arg, info[0], m_packet.m_packet, "argument 1 of AdaptPacketContext::ParseValue" )
480
+
481
+ AW_Value ret;
482
+ std::string msg = m_packet.ParseValue( ret, arg );
483
+ ERROR_CHECK( msg );
484
+ ADAPT_RETURN_VALUE( ret, m_packet );
485
+ }
486
+
487
+ Napi::Value AdaptPacketContext::ParseValueFromJSON( const Napi::CallbackInfo& info )
488
+ {
489
+ ADAPT_EXPECT_ARGC( 1 );
490
+ ADAPT_EXPECT_ARG_STRING( 0 );
491
+
492
+ AW_Value ret;
493
+ std::string msg = m_packet.ParseValueFromJSON( ret, info[0].ToString() );
494
+ ERROR_CHECK( msg );
495
+ ADAPT_RETURN_VALUE( ret, m_packet );
496
+ }
497
+
498
+ Napi::Value AdaptPacketContext::CreateDictionary( const Napi::CallbackInfo& info )
499
+ {
500
+ ADAPT_EXPECT_ARGC( 0 );
501
+
502
+ AW_Value ret;
503
+ std::string msg = m_packet.CreateDictionary( ret );
504
+ ERROR_CHECK( msg );
505
+ ADAPT_RETURN_VALUE( ret, m_packet );
506
+ }
507
+
508
+ Napi::Value AdaptPacketContext::NewBinaryFromHex( const Napi::CallbackInfo& info )
509
+ {
510
+ ADAPT_EXPECT_ARGC( 1 );
511
+ ADAPT_EXPECT_ARG_STRING( 0 );
512
+ std::string arg = info[0].ToString();
513
+
514
+ AW_Value ret;
515
+ std::string msg = m_packet.NewBinaryFromHex( ret, arg );
516
+ ERROR_CHECK( msg );
517
+ ADAPT_RETURN_VALUE( ret, m_packet );
518
+ }
519
+
520
+ Napi::Value AdaptPacketContext::NewBinaryFromBuffer( const Napi::CallbackInfo& info )
521
+ {
522
+ ADAPT_EXPECT_ARGC( 1 );
523
+ ADAPT_EXPECT_ARG_BUFFER( 0 );
524
+ auto buffer = info[0].As<Napi::Buffer<unsigned char>>();
525
+ auto data = buffer.Data();
526
+ auto length = buffer.Length();
527
+
528
+ AW_Value ret;
529
+ std::string msg = m_packet.NewBinaryFromBuffer( ret, data, length );
530
+ ERROR_CHECK( msg );
531
+ ADAPT_RETURN_VALUE( ret, m_packet );
532
+ }
533
+
534
+ Napi::Value AdaptPacketContext::ExecuteTransaction( const Napi::CallbackInfo& info )
535
+ {
536
+ ADAPT_EXPECT_ARGC( 3 );
537
+ AW_Value arg;
538
+ ADAPT_EXPECT_OBJECT( arg, info[0], m_packet.m_packet, "argument 1 of AdaptPacketContext::ExecuteTransaction" )
539
+ ADAPT_EXPECT_ARG_STRING( 1 );
540
+ AW_Value __timestamp;
541
+ ADAPT_EXPECT_OBJECT( __timestamp, info[2], m_packet.m_packet, "argument 3 of AdaptPacketContext::ExecuteTransaction" );
542
+
543
+ AW_Value ret;
544
+ std::string msg = m_packet.ExecuteTransaction( ret, arg, info[1].ToString(), __timestamp );
545
+ ERROR_CHECK( msg );
546
+ ADAPT_RETURN_VALUE( ret, ret );
547
+ }
548
+
549
+ Napi::Value AdaptPacketContext::ExecuteFunction( const Napi::CallbackInfo& info )
550
+ {
551
+ ADAPT_EXPECT_ARGC( 2 );
552
+ ADAPT_EXPECT_ARG_STRING( 0 ); // function name
553
+ auto __arg = info[1].As<Napi::Array>();
554
+ std::vector<AW_Value> args;
555
+ for( size_t i = 0; i < __arg.Length(); i++ )
556
+ {
557
+ AdaptValue* val = nullptr;
558
+ try
559
+ {
560
+ val = AdaptValue::Unwrap( __arg[i].operator Napi::Value().ToObject() );
561
+ }
562
+ catch( ... )
563
+ {
564
+ }
565
+
566
+ if( val == nullptr )
567
+ Napi::Error::New( info.Env(), "Invalid argument. Expected list of AdaptValues" );
568
+ args.push_back( val->m_value );
569
+ }
570
+
571
+ AW_Value ret;
572
+ std::string msg = m_packet.ExecuteFunction( ret, info[0].ToString(), args );
573
+ ERROR_CHECK( msg );
574
+ ADAPT_RETURN_VALUE( ret, ret );
575
+ }
576
+
577
+ Napi::Value AdaptPacketContext::GetHash( const Napi::CallbackInfo& info )
578
+ {
579
+ ADAPT_EXPECT_ARGC( 0 );
580
+ AW_Value ret;
581
+ std::string msg = m_packet.GetHash( ret );
582
+ ERROR_CHECK( msg );
583
+ ADAPT_RETURN_VALUE( ret, ret );
584
+ }
585
+
586
+ Napi::Value AdaptPacketContext::GetContainerID( const Napi::CallbackInfo& info )
587
+ {
588
+ ADAPT_EXPECT_ARGC( 0 );
589
+ AW_Value ret;
590
+ std::string msg = m_packet.GetContainerID( ret );
591
+ ERROR_CHECK( msg );
592
+ ADAPT_RETURN_VALUE( ret, ret );
593
+ }
594
+
595
+ Napi::Value AdaptPacketContext::GetCodeID( const Napi::CallbackInfo& info )
596
+ {
597
+ ADAPT_EXPECT_ARGC( 0 );
598
+ AW_Value ret;
599
+ std::string msg = m_packet.GetCodeID( ret );
600
+ ERROR_CHECK( msg );
601
+ ADAPT_RETURN_VALUE( ret, ret );
602
+ }
603
+
604
+ Napi::Value AdaptPacketContext::Serialize( const Napi::CallbackInfo& info )
605
+ {
606
+ ADAPT_EXPECT_ARGC( 0 );
607
+
608
+ AW_Value result;
609
+ unsigned char* data{};
610
+ size_t length{};
611
+ std::string msg = m_packet.Serialize( data, length );
612
+ ERROR_CHECK( msg );
613
+ return Napi::Buffer<unsigned char>::New( info.Env(), data, length );
614
+ }
615
+
616
+ Napi::Value AdaptPacketContext::TransactionsList( const Napi::CallbackInfo& info )
617
+ {
618
+ ADAPT_EXPECT_ARGC( 0 );
619
+
620
+ std::vector<std::string> result;
621
+
622
+ std::string msg = m_packet.TransactionsList( result );
623
+ ERROR_CHECK( msg );
624
+
625
+ auto ret = Napi::Array::New( info.Env(), result.size() );
626
+ for( size_t i = 0; i < result.size(); i++ )
627
+ {
628
+ ret[i] = Napi::String::New( info.Env(), result[i] );
629
+ }
630
+
631
+ return ret;
632
+ }
633
+
634
+ Napi::Value AdaptPacketContext::NilObject( const Napi::CallbackInfo& info )
635
+ {
636
+ ADAPT_EXPECT_ARGC( 0 );
637
+ AW_Value result;
638
+
639
+ std::string msg = m_packet.NilObject( result );
640
+ ERROR_CHECK( msg );
641
+
642
+ ADAPT_RETURN_VALUE( result, result );
643
+ }
644
+ AdaptValue::AdaptValue( const Napi::CallbackInfo& info )
645
+ : Napi::ObjectWrap<AdaptValue>( info )
646
+ {
647
+ if( !AW_Environment ::isInitialized() )
648
+ {
649
+ Napi::Error::New( info.Env(), "Adapt environment not initialized" );
650
+ }
651
+
652
+ if( info.Length() == 0 )
653
+ {
654
+ return;
655
+ }
656
+
657
+ if( info.Length() > 2 )
658
+ {
659
+ Napi::TypeError::New( info.Env(), "AdaptValue constructor expects (Convertible[, Packet])" ).ThrowAsJavaScriptException();
660
+ return;
661
+ };
662
+
663
+ AW_PacketContext p;
664
+ if( info.Length() == 2 )
665
+ {
666
+ AdaptPacketContext* __arg = nullptr;
667
+ try
668
+ {
669
+ __arg = AdaptPacketContext::Unwrap( info[1].ToObject() );
670
+ }
671
+ catch( ... )
672
+ {
673
+ }
674
+
675
+ if( __arg != nullptr )
676
+ {
677
+ p.m_packet.reset_ptr( __arg->m_packet.m_packet );
678
+ }
679
+ }
680
+ if( info[0].IsString() )
681
+ {
682
+ m_value.ResetFromString( info[0].As<Napi::String>(), p.m_packet );
683
+ }
684
+ else if( info[0].IsNumber() )
685
+ {
686
+ m_value.ResetFromNumber( info[0].As<Napi::Number>(), p.m_packet );
687
+ }
688
+ else if( info[0].IsBoolean() )
689
+ {
690
+ m_value.ResetFromBoolean( info[0].As<Napi::Boolean>(), p.m_packet );
691
+ }
692
+ else if( info[0].IsEmpty() )
693
+ {
694
+ m_value.ResetFromBoolean( false, p.m_packet );
695
+ }
696
+ else if( info[0].IsUndefined() || info[0].IsNull() )
697
+ {
698
+ m_value.ResetNil( p.m_packet );
699
+ }
700
+ // else if( info[0].IsArray() )
701
+ // {
702
+ // Napi::Array v = info[0].As<Napi::Array>();
703
+ // for( size_t i = 0; i < v.Length(); i ++ )
704
+ // {
705
+ // Napi::Value elem = v.Get( i );
706
+ // }
707
+ // }
708
+ else
709
+ {
710
+ Napi::TypeError::New( info.Env(), "First argument type invalid" ).ThrowAsJavaScriptException();
711
+ return;
712
+ }
713
+ }
714
+
715
+ Napi::FunctionReference* AdaptValue::constructor;
716
+
717
+ Napi::Object AdaptValue::Init( Napi::Env env, Napi::Object exports )
718
+ {
719
+ Napi::Function func = DefineClass( env,
720
+ "AdaptValue",
721
+ { InstanceMethod( "Destroy", &AdaptValue::Destroy ),
722
+ InstanceMethod( "Clone", &AdaptValue::Clone ),
723
+ InstanceMethod( "Visualize", &AdaptValue::Visualize ),
724
+ InstanceMethod( "Serialize", &AdaptValue::Serialize ),
725
+ InstanceMethod( "GetHash", &AdaptValue::GetHash ),
726
+ InstanceMethod( "Reduce", &AdaptValue::Reduce ),
727
+ InstanceMethod( "Mutate", &AdaptValue::Mutate ),
728
+ InstanceMethod( "GetPacket", &AdaptValue::GetPacket ),
729
+ InstanceMethod( "GetNumber", &AdaptValue::GetNumber ),
730
+ InstanceMethod( "GetBoolean", &AdaptValue::GetBoolean ),
731
+ InstanceMethod( "GetBinary", &AdaptValue::GetBinary ),
732
+ InstanceMethod( "IsNil", &AdaptValue::IsNil ),
733
+ InstanceMethod( "Equals", &AdaptValue::Equals ),
734
+ InstanceMethod( "Less", &AdaptValue::Less ),
735
+ InstanceMethod( "GetKeys", &AdaptValue::GetKeys ) } );
736
+
737
+ constructor = new Napi::FunctionReference();
738
+ *constructor = Napi::Persistent( func );
739
+ constructor->SuppressDestruct();
740
+
741
+ env.SetInstanceData( constructor );
742
+
743
+ exports.Set( "AdaptValue", func );
744
+ return exports;
745
+ }
746
+
747
+ Napi::Object AdaptValue::NewInstance( Napi::Env env, Napi::Value arg )
748
+ {
749
+ Napi::EscapableHandleScope scope( env );
750
+ Napi::Object obj = env.GetInstanceData<Napi::FunctionReference>()->New( { arg } );
751
+ return scope.Escape( napi_value( obj ) ).ToObject();
752
+ }
753
+
754
+ Napi::Value AdaptValue::Destroy( const Napi::CallbackInfo& info )
755
+ {
756
+ ADAPT_EXPECT_ARGC( 0 );
757
+
758
+ m_value.Destroy();
759
+
760
+ ADAPT_RETURN_UNDEFINED;
761
+ }
762
+
763
+ Napi::Value AdaptValue::Clone( const Napi::CallbackInfo& info )
764
+ {
765
+ ADAPT_EXPECT_ARGC( 0 );
766
+
767
+ AW_Value result;
768
+ std::string msg = m_value.Clone( result );
769
+ ERROR_CHECK( msg );
770
+
771
+ ADAPT_RETURN_VALUE( result, result );
772
+ }
773
+
774
+ Napi::Value AdaptValue::Visualize( const Napi::CallbackInfo& info )
775
+ {
776
+ ADAPT_EXPECT_ARGC( 0 );
777
+ std::string result;
778
+ std::string msg = m_value.Visualize( result );
779
+ ERROR_CHECK( msg );
780
+ return Napi::String::New( info.Env(), result.c_str() );
781
+ }
782
+
783
+ Napi::Value AdaptValue::Serialize( const Napi::CallbackInfo& info )
784
+ {
785
+ ADAPT_EXPECT_ARGC( 0 );
786
+ unsigned char* data{};
787
+ size_t length{};
788
+ std::string msg = m_value.Serialize( data, length );
789
+ ERROR_CHECK( msg );
790
+ return Napi::Buffer<unsigned char>::New( info.Env(), data, length );
791
+ }
792
+
793
+ Napi::Value AdaptValue::GetHash( const Napi::CallbackInfo& info )
794
+ {
795
+ ADAPT_EXPECT_ARGC( 0 );
796
+ AW_Value result;
797
+ std::string msg = m_value.GetHash( result );
798
+ ERROR_CHECK( msg );
799
+ ADAPT_RETURN_VALUE( result, result );
800
+ }
801
+
802
+ Napi::Value AdaptValue::Reduce( const Napi::CallbackInfo& info )
803
+ {
804
+ ADAPT_EXPECT_ARGC( 1 );
805
+ AW_Value arg;
806
+ ADAPT_EXPECT_OBJECT( arg, info[0], m_value.m_packet, "argument 0 of AdaptValue::Reduce" )
807
+
808
+ AW_Value result;
809
+ std::string msg = m_value.Reduce( arg, result );
810
+ ERROR_CHECK( msg );
811
+ ADAPT_RETURN_VALUE( result, result );
812
+ }
813
+
814
+ Napi::Value AdaptValue::Mutate( const Napi::CallbackInfo& info )
815
+ {
816
+ ADAPT_EXPECT_ARGC( 2 );
817
+ AW_Value reducer, product;
818
+ ADAPT_EXPECT_OBJECT( reducer, info[0], m_value.m_packet, "argument 0 of AdaptValue::Mutate" );
819
+ ADAPT_EXPECT_OBJECT( product, info[1], m_value.m_packet, "argument 1 of AdaptValue::Mutate" );
820
+
821
+ AW_Value result;
822
+ std::string msg = m_value.Mutate( reducer, product, result );
823
+ ERROR_CHECK( msg );
824
+ ADAPT_RETURN_VALUE( result, result );
825
+ }
826
+
827
+ Napi::Value AdaptValue::GetPacket( const Napi::CallbackInfo& info )
828
+ {
829
+ auto instance = AdaptPacketContext::constructor->New( {} );
830
+ auto value = AdaptPacketContext::Unwrap( instance );
831
+ value->m_packet.m_packet.dup( m_value.m_packet );
832
+ return instance;
833
+ }
834
+
835
+ Napi::Value AdaptValue::GetNumber( const Napi::CallbackInfo& info )
836
+ {
837
+ ADAPT_EXPECT_ARGC( 0 );
838
+ int result;
839
+ std::string msg = m_value.ToInt( result );
840
+ ERROR_CHECK( msg );
841
+ return Napi::Number::New( info.Env(), result );
842
+ }
843
+
844
+ Napi::Value AdaptValue::GetBoolean( const Napi::CallbackInfo& info )
845
+ {
846
+ ADAPT_EXPECT_ARGC( 0 );
847
+ bool result;
848
+ std::string msg = m_value.ToBool( result );
849
+ ERROR_CHECK( msg );
850
+ return Napi::Boolean::New( info.Env(), result );
851
+ }
852
+
853
+ Napi::Value AdaptValue::GetBinary( const Napi::CallbackInfo& info )
854
+ {
855
+ ADAPT_EXPECT_ARGC( 0 );
856
+ unsigned char* data{};
857
+ size_t length{};
858
+ std::string msg = m_value.ToBinary( data, length );
859
+ ERROR_CHECK( msg );
860
+ return Napi::Buffer<unsigned char>::New( info.Env(), data, length );
861
+ }
862
+
863
+ Napi::Value AdaptValue::IsNil( const Napi::CallbackInfo& info )
864
+ {
865
+ ADAPT_EXPECT_ARGC( 0 );
866
+ bool result;
867
+ std::string msg = m_value.IsNil( result );
868
+ ERROR_CHECK( msg );
869
+ return Napi::Boolean::New( info.Env(), result );
870
+ }
871
+
872
+ Napi::Value AdaptValue::Equals( const Napi::CallbackInfo& info )
873
+ {
874
+ ADAPT_EXPECT_ARGC( 1 );
875
+ AW_Value rhs;
876
+ ADAPT_EXPECT_OBJECT( rhs, info[0], m_value.m_packet, "argument 0 of AdaptValue::Equals" );
877
+
878
+ bool result;
879
+ std::string msg = m_value.Equals( result, rhs );
880
+ ERROR_CHECK( msg );
881
+ return Napi::Boolean::New( info.Env(), result );
882
+ }
883
+
884
+ Napi::Value AdaptValue::Less( const Napi::CallbackInfo& info )
885
+ {
886
+ ADAPT_EXPECT_ARGC( 1 );
887
+ AW_Value rhs;
888
+ ADAPT_EXPECT_OBJECT( rhs, info[0], m_value.m_packet, "argument 0 of AdaptValue::Less" );
889
+
890
+ bool result;
891
+ std::string msg = m_value.Less( result, rhs );
892
+ ERROR_CHECK( msg );
893
+ return Napi::Boolean::New( info.Env(), result );
894
+ }
895
+
896
+ Napi::Value AdaptValue::GetKeys( const Napi::CallbackInfo& info )
897
+ {
898
+ ADAPT_EXPECT_ARGC( 0 );
899
+ std::vector<AW_Value> result;
900
+
901
+ std::string msg = m_value.GetKeys( result );
902
+ ERROR_CHECK( msg );
903
+
904
+ auto ret = Napi::Array::New( info.Env(), result.size() );
905
+ for( size_t i = 0; i < result.size(); i++ )
906
+ {
907
+ auto instance = AdaptValue::constructor->New( {} );
908
+ auto value = AdaptValue::Unwrap( instance );
909
+ value->m_value.m_value.move( result[i].m_value );
910
+ value->m_value.m_packet.reset_ptr( result[i].m_packet );
911
+ ret[i] = instance;
912
+ }
913
+
914
+ return ret;
915
+ }