// copyright nobody

// LINT_C_FILE

/*

file sqlmath_napi.h

*/

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#ifdef WIN32

#include <windows.h>

#endif

#include <sqlite3.h>

#include <node_api.h>

#define ALLOCF free

#define SIZEOF_BUFFER_DEFAULT 1024

#define UNUSED(x) (void)(x)

/*

file sqlmath_assert.c

*/

// printf("\n\n[napi errcode=%d]\n\n", errcode);

// this function will if <cond> is falsy, set <baton->errmsg> to <msg>

#define ASSERT_BATON(baton, cond, msg) \

if (baton->errmsg[0] != 0) { \

return 0; \

} \

if (!(cond)) { \

__snprintfTrace(baton->errmsg, msg, __func__, __FILE__, __LINE__); \

return 0; \

}

// this function will if <cond> is falsy, terminate process with <msg>

#define ASSERT_FATAL(cond, msg) \

if (!(cond)) { \

napi_fatal_error(__func__, NAPI_AUTO_LENGTH , msg, NAPI_AUTO_LENGTH); \

}

// this function will if <cond> is falsy, throw <msg> in <env>

#define ASSERT_NAPI(env, cond, msg) \

if (!(cond)) { \

char buf[256] = { 0 }; \

napi_throw_error(env, NULL, \

__snprintfTrace(buf, msg, __func__, __FILE__, __LINE__)); \

return 0; \

}

// this function will assert <errcode> == napi_ok in <env>

#define ASSERT_NAPI_OK(env, errcode) \

if (0 != assertNapiOk(env, __func__, __FILE__, __LINE__, errcode)) { \

return 0; \

}

// this function will assert <errcode> == SQLITE_OK in <db>

#define ASSERT_SQLITE_OK(baton, db, errcode) \

if (errcode != SQLITE_OK) { \

ASSERT_BATON( \

baton, \

false, \

(db == NULL ? sqlite3_errstr(errcode) : sqlite3_errmsg(db))); \

}

static const char *__snprintfTrace(

char *buf,

const char *errmsg,

const char *func,

const char *file,

int line

) {

// this function will write <errmsg> to <buf> with additional trace-info

if (snprintf(buf, // NO_LINT

256, "%s\n at %s (%s:%d)", errmsg, func, file, line) < 0) {

abort();

}

return (const char *) buf;

}

static int assertNapiOk(

napi_env env,

const char *func,

const char *file,

int line,

int errcode

) {

// this function will throw error if <errcode> != napi_ok

// derived from https://github.com/nodejs/node-addon-api/blob/3.2.1/napi-inl.h

// typedef struct {

// const char* error_message;

// void* engine_reserved;

// uint32_t engine_error_code;

// napi_status error_code;

// } napi_extended_error_info;

if (errcode == napi_ok) {

return errcode;

}

// declare var

char buf[256] = { 0 };

bool is_exception_pending;

const napi_extended_error_info *info;

napi_value val = NULL;

// We must retrieve the last error info before doing anything else, because

// doing anything else will replace the last error info.

#ifdef _MSC_VER

#pragma warning(push)

#pragma warning(disable: 26812)

#endif

errcode = napi_get_last_error_info(env, &info);

#ifdef _MSC_VER

#pragma warning(pop)

#endif

ASSERT_FATAL(errcode == 0, "napi_get_last_error_info");

errcode = napi_is_exception_pending(env, &is_exception_pending);

ASSERT_FATAL(errcode == 0, "napi_is_exception_pending");

// A pending exception takes precedence over any internal error status.

if (is_exception_pending) {

errcode = napi_get_and_clear_last_exception(env, &val);

ASSERT_FATAL(errcode == 0, "napi_get_and_clear_last_exception");

napi_throw(env, val);

return errcode;

}

errcode =

napi_throw_error(env, NULL, __snprintfTrace(buf,

(info->error_message !=

NULL ? info->error_message : "error in native code"), func,

file, line));

ASSERT_FATAL(errcode == 0, "napi_throw_error");

return errcode;

}

/*

file sqlmath_promise.c

*/

#define JSBATON_CREATE(env, info) \

jsbatonCreate(env, info); if (baton == NULL) {return NULL;}

#define JSPROMISE_CREATE(func, env, data) \

__##func(void *data); \

static void _##func(napi_env env, void *data) { \

UNUSED(env); \

__##func(data); \

} \

static napi_value func(napi_env env, napi_callback_info info) { \

return jspromiseCreate(env, info, _##func); \

} \

static int __##func(void *data)

typedef struct Jsbaton {

// data

int64_t int8[8];

char *buf8[8];

char *out8[8];

char errmsg[256];

napi_value result;

// async

napi_async_work work;

napi_deferred deferred;

} Jsbaton;

static void jsbatonBufferFinalize(

napi_env env,

void *finalize_data,

void *finalize_hint

) {

// this function will finalize <finalize_data>

UNUSED(env);

UNUSED(finalize_hint);

// printf("\n\n[napi finalize_data=%s]\n\n", (const char *) finalize_data);

// printf("\n\n[napi finalize_hint=%s]\n\n", (const char *) finalize_hint);

ALLOCF(finalize_data);

}

static Jsbaton *jsbatonCreate(

napi_env env,

napi_callback_info info

) {

// this function will create a baton for passing data between nodejs <-> c

// declare var

Jsbaton *baton = NULL;

bool istrue;

int errcode = 0;

napi_value tmp;

size_t ii = 1;

// init argv

errcode = napi_get_cb_info(env, info, &ii, &tmp, NULL, NULL);

ASSERT_NAPI_OK(env, errcode);

// init baton

errcode = napi_get_element(env, tmp, 0, (napi_value *) & baton);

ASSERT_NAPI_OK(env, errcode);

errcode =

napi_get_typedarray_info(env, (napi_value) baton, NULL, NULL,

(void **) &baton, NULL, NULL);

ASSERT_NAPI_OK(env, errcode);

baton->result = tmp;

// init buf8

ii = 0;

while (ii < 8) {

errcode = napi_get_element(env, baton->result, ii + 1, &tmp);

ASSERT_NAPI_OK(env, errcode);

errcode = napi_is_buffer(env, tmp, &istrue);

ASSERT_NAPI_OK(env, errcode);

if (istrue) {

errcode =

napi_get_buffer_info(env, tmp,

(void **) &baton->buf8[ii], NULL);

ASSERT_NAPI_OK(env, errcode);

}

ii += 1;

}

return baton;

}

static napi_value jsbatonExport(

napi_env env,

Jsbaton * baton

) {

// this function will export c-data to js-data in <jsbaton>

// declare var

int errcode = 0;

napi_value val;

size_t ii = 0;

while (ii < 8) {

if (baton->out8[ii] == NULL) {

errcode = napi_create_double(env, (double) baton->int8[ii], &val);

ASSERT_NAPI_OK(env, errcode);

} else {

errcode = napi_create_external_arraybuffer(env, // napi_env env,

(void *) baton->out8[ii], // void* external_data,

(size_t) baton->int8[ii], // size_t byte_length,

jsbatonBufferFinalize, // napi_finalize finalize_cb,

NULL, // void* finalize_hint,

&val); // napi_value* result

ASSERT_NAPI_OK(env, errcode);

}

errcode = napi_set_element(env, baton->result, ii + 1, val);

ASSERT_NAPI_OK(env, errcode);

ii += 1;

}

return baton->result;

}

static napi_value jsstringCreate(

napi_env env,

const char *ss

) {

// This API creates a JavaScript string value from a UTF8-encoded C string.

// The native string is copied.

// declare var

int errcode = 0;

napi_value result = NULL;

// return result

errcode = napi_create_string_utf8(env, ss, NAPI_AUTO_LENGTH, &result);

ASSERT_NAPI_OK(env, errcode);

return result;

}

static int __jspromiseResolve(

napi_env env,

napi_status errcode,

void *data

) {

// This function runs on the main thread after `jspromiseExecute` exits.

ASSERT_FATAL(errcode == 0, __func__);

// init baton

Jsbaton *baton = (Jsbaton *) data;

// declare var

napi_ref ref = (napi_ref) baton->result;

uint32_t refcount = 1;

// dereference result to allow gc

errcode = napi_reference_unref(env, ref, &refcount);

ASSERT_FATAL(errcode == 0, "napi_reference_unref");

ASSERT_FATAL(refcount == 0, "memory leak");

errcode = napi_get_reference_value(env, ref, &baton->result);

ASSERT_FATAL(errcode == 0, "napi_get_reference_value");

errcode = napi_delete_reference(env, ref);

ASSERT_FATAL(errcode == 0, "napi_delete_reference");

// Resolve or reject the promise associated with the deferred depending on

// whether the asynchronous action succeeded.

if (baton->errmsg[0] == 0) {

// resolve promise with result

if (jsbatonExport(env, baton) == NULL) {

return 0;

}

errcode = napi_resolve_deferred(env, baton->deferred, baton->result);

ASSERT_FATAL(errcode == 0, "napi_resolve_deferred");

} else {

// declare var

napi_value err;

// create error

errcode =

napi_create_error(env, NULL, jsstringCreate(env, baton->errmsg),

&err);

ASSERT_FATAL(errcode == 0, "napi_create_error");

// reject promise with error

errcode = napi_reject_deferred(env, baton->deferred, err);

ASSERT_FATAL(errcode == 0, "napi_reject_deferred");

}

// Clean up the work item associated with this run.

errcode = napi_delete_async_work(env, baton->work);

ASSERT_FATAL(errcode == 0, "napi_delete_async_work");

// Set both values to NULL so JavaScript can order a new run of the thread.

baton->work = NULL;

baton->deferred = NULL;

return 0;

}

static void jspromiseResolve(

napi_env env,

napi_status errcode,

void *data

) {

// This function runs on the main thread after `jspromiseExecute` exits.

__jspromiseResolve(env, errcode, data);

}

static napi_value jspromiseCreate(

napi_env env,

napi_callback_info info,

napi_async_execute_callback jspromiseExecute

) {

// Create a deferred promise and an async queue work item.

// init baton

Jsbaton *baton = JSBATON_CREATE(env, info);

// declare var

int errcode = 0;

napi_value promise = 0;

napi_value async_resource_name =

jsstringCreate(env, "Node-API Deferred Promise from Async Work Item");

// reference result to prevent gc

errcode = napi_create_reference(env, // napi_env env

baton->result, // napi_value value

1, // uint32_t initial_refcount

(napi_ref *) & baton->result); // napi_ref* result

ASSERT_NAPI_OK(env, errcode);

// Ensure that no work is currently in progress.

ASSERT_NAPI(env, baton->work == NULL,

"Only one work item must exist at a time");

// Create a deferred promise which we will resolve at the completion of the

// work.

errcode = napi_create_promise(env, &(baton->deferred), &promise);

ASSERT_NAPI_OK(env, errcode);

// Create an async work item, passing in the addon data, which will give the

// worker thread access to the above-created deferred promise.

errcode = napi_create_async_work(env, // napi_env env,

NULL, // napi_value async_resource,

async_resource_name, // napi_value async_resource_name,

jspromiseExecute, // napi_async_execute_callback execute,

jspromiseResolve, // napi_async_complete_callback complete,

baton, // void* data,

&(baton->work)); // napi_async_work* result);

ASSERT_NAPI_OK(env, errcode);

// Queue the work item for execution.

errcode = napi_queue_async_work(env, baton->work);

ASSERT_NAPI_OK(env, errcode);

// This causes created `promise` to be returned to JavaScript.

return promise;

}

/*

file sqlmath_db.c

*/

static int JSPROMISE_CREATE(

__sqlite3_close_v2,

env,

data

) {

// int sqlite3_close_v2(sqlite3*);

// init baton

Jsbaton *baton = (Jsbaton *) data;

// declare var

int errcode = 0;

sqlite3 *db = (sqlite3 *) (intptr_t) baton->int8[0];

// printf("\n\n[napi close=%zd]\n\n", (intptr_t) db);

// call sqlite3_close_v2()

errcode = sqlite3_close_v2(db);

ASSERT_SQLITE_OK(baton, db, errcode);

// save result

baton->int8[0] = (int64_t) (intptr_t) db;

return 0;

}

static int JSPROMISE_CREATE(

__sqlite3_open_v2,

env,

data

) {

// int sqlite3_open_v2(

// const char *filename, /* Database filename (UTF-8) */

// sqlite3 **ppDb, /* OUT: SQLite db handle */

// int flags, /* Flags */

// const char *zVfs /* Name of VFS module to use */

// );

// init baton

Jsbaton *baton = (Jsbaton *) data;

// declare var

const char *filename = (const char *) baton->buf8[0];

int errcode = 0;

int flags = (int) baton->int8[2];

sqlite3 *db = NULL;

// validate filename

// printf("\n\n[napi filename=%s]\n\n", filename);

ASSERT_BATON(baton, filename != NULL, "filename == NULL");

// call sqlite3_open_v2()

errcode = sqlite3_open_v2(filename, &db, flags, NULL);

ASSERT_SQLITE_OK(baton, db, errcode);

// printf("\n\n[napi db=%zd]\n\n", (intptr_t) db);

// save result

baton->int8[0] = (int64_t) (intptr_t) db;

return 0;

}

static int JSPROMISE_CREATE(

_dbExec,

env,

data

) {

// This function will run <zSql> in <db> and save any result (list of tables

// containing rows from SELECT/pragma/etc) as serialized a json-string in

// <pResult>.

/* *INDENT-OFF* */

void dbExec(sqlite3 *, const char *, char **, int *, char *);

/* *INDENT-ON* */

// init baton

Jsbaton *baton = (Jsbaton *) data;

// declare var

char *zBuf = NULL;

char zErrmsg[256] = { 0 };

const char *zSql = (const char *) baton->buf8[1];

int nAlloced = 0;

sqlite3 *db = (sqlite3 *) (intptr_t) baton->int8[0];

// validate zSql

// printf("\n\n[napi zSql=%s]\n\n", zSql);

ASSERT_BATON(baton, zSql != NULL, "zSql == NULL");

// call dbExec()

dbExec(db, zSql, &zBuf, &nAlloced, zErrmsg);

// printf("\n\n[napi nAlloced=%d zBuf=%s]\n\n", nAlloced, zBuf);

ASSERT_BATON(baton, zErrmsg[0] == '\x00', zErrmsg);

// save result

baton->int8[0] = (int64_t) nAlloced;

baton->out8[0] = zBuf;

return 0;

}

/*

file sqlmath_noop.c

*/

static void noopAsyncExecute(

napi_env env,

void *data

) {

// This function runs on a worker thread. It has no access to the JavaScript.

UNUSED(env);

// init baton

Jsbaton *baton = (Jsbaton *) data;

UNUSED(baton);

}

static napi_value noopAsync(

napi_env env,

napi_callback_info info

) {

// Create a deferred promise and an async queue work item.

return jspromiseCreate(env, info, noopAsyncExecute);

}

/*

static int JSPROMISE_CREATE(noopAsync, env, data) {

// This function runs on a worker thread. It has no access to the JavaScript.

UNUSED(env);

// init baton

Jsbaton *baton = (Jsbaton *) data;

UNUSED(baton);

}

*/

static napi_value noopSync(

napi_env env,

napi_callback_info info

) {

// this function will do nothing

// init baton

Jsbaton *baton = JSBATON_CREATE(env, info);

return jsbatonExport(env, baton);

}

/*

file napi_module_init.c

*/

napi_value napi_module_init(

napi_env env,

napi_value exports

) {

// typedef struct {

// // One of utf8name or name should be NULL.

// const char* utf8name;

// napi_value name;

//

// napi_callback method;

// napi_callback getter;

// napi_callback setter;

// napi_value value;

//

// napi_property_attributes attributes;

// void* data;

// } napi_property_descriptor;

#define NAPI_EXPORT_MEMBER(name) \

{#name, NULL, name, NULL, NULL, NULL, napi_default, NULL}

int errcode = 0;

const napi_property_descriptor propList[] = {

NAPI_EXPORT_MEMBER(_dbExec),

NAPI_EXPORT_MEMBER(__sqlite3_close_v2),

NAPI_EXPORT_MEMBER(__sqlite3_open_v2),

NAPI_EXPORT_MEMBER(noopAsync),

NAPI_EXPORT_MEMBER(noopSync),

};

errcode = napi_define_properties(env, exports,

sizeof(propList) / sizeof(napi_property_descriptor), propList);

ASSERT_NAPI_OK(env, errcode);

return exports;

}

NAPI_MODULE(NODE_GYP_MODULE_NAME, napi_module_init)