@bullet./paraql 0.1.0 → 0.2.0

package/binding.c

@@ -3,6 +3,7 @@
 #include <js.h>
 #include <sqlite3.h>
 #include <stdbool.h>
+#include <stddef.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
@@ -100,29 +101,40 @@ typedef struct {
   int status;
 } paravfs_delete_t;
 
-typedef struct paraql_statement_s paraql_statement_t;
-
 typedef struct {
   sqlite3 *handle;
 
   js_env_t *env;
+  js_ref_t *ctx;
 
-  paraql_statement_t *statements;
+  js_threadsafe_function_t *on_auth;
 } paraql_t;
 
-struct paraql_statement_s {
+typedef struct {
+  int action;
+
+  const char *param1;
+  const char *param2;
+  const char *param3;
+  const char *param4;
+
+  uv_sem_t done;
+
+  int status;
+} paraql_auth_t;
+
+typedef struct {
   sqlite3_stmt *handle;
 
   paraql_t *db;
-  paraql_statement_t *prev;
-  paraql_statement_t *next;
-};
+} paraql_statement_t;
 
 typedef struct {
   uv_work_t handle;
 
   paraql_t *db;
 
+  js_ref_t *ref;
   js_deferred_t *deferred;
 
   paraql_path_t name;
@@ -160,6 +172,7 @@ typedef struct {
 
   paraql_t *db;
 
+  js_ref_t *ref;
   js_deferred_t *deferred;
 
   utf8_t *sql;
@@ -276,6 +289,22 @@ typedef struct {
   const char *errmsg;
 } paraql_run_t;
 
+typedef struct {
+  uv_work_t handle;
+
+  js_env_t *env;
+
+  js_deferred_t *deferred;
+
+  paraql_t *db;
+
+  sqlite3_int64 size;
+  unsigned char *data;
+
+  int errcode;
+  const char *errmsg;
+} paraql_serialize_t;
+
 static const size_t paraql__queue_limit = 64;
 
 static int
@@ -1048,53 +1077,6 @@ paravfs_destroy(js_env_t *env, js_callback_info_t *info) {
   return NULL;
 }
 
-static void
-paraql__insert_statement(paraql_t *db, paraql_statement_t *stmt) {
-  stmt->db = db;
-  stmt->prev = NULL;
-  stmt->next = db->statements;
-
-  if (db->statements != NULL) db->statements->prev = stmt;
-
-  db->statements = stmt;
-}
-
-static void
-paraql__remove_statement(paraql_statement_t *stmt) {
-  if (stmt->db == NULL) return;
-
-  if (stmt->prev != NULL) stmt->prev->next = stmt->next;
-  else stmt->db->statements = stmt->next;
-
-  if (stmt->next != NULL) stmt->next->prev = stmt->prev;
-
-  stmt->db = NULL;
-  stmt->prev = NULL;
-  stmt->next = NULL;
-}
-
-static void
-paraql__finalize_statements(paraql_t *db) {
-  paraql_statement_t *stmt = db->statements;
-
-  while (stmt != NULL) {
-    paraql_statement_t *next = stmt->next;
-
-    if (stmt->handle != NULL) {
-      sqlite3_finalize(stmt->handle);
-      stmt->handle = NULL;
-    }
-
-    stmt->db = NULL;
-    stmt->prev = NULL;
-    stmt->next = NULL;
-
-    stmt = next;
-  }
-
-  db->statements = NULL;
-}
-
 static const char *
 paraql__code(int errcode) {
   switch (errcode & 0xff) {
@@ -1150,72 +1132,108 @@ paraql__make_error(js_env_t *env, int errcode, const char *errmsg, js_value_t **
   return js_create_error(env, code, message, error);
 }
 
-static void
-paraql__on_after_finalize_db(uv_work_t *handle, int status) {
-  free(handle);
-}
+static js_value_t *
+paraql__on_auth_done(js_env_t *env, js_callback_info_t *info) {
+  int err;
 
-static void
-paraql__on_before_finalize_db(uv_work_t *handle) {
-  paraql_t *db = (paraql_t *) handle->data;
+  paraql_auth_t *data;
 
-  paraql__finalize_statements(db);
+  size_t argc = 1;
+  js_value_t *argv[1];
 
-  if (db->handle != NULL) sqlite3_close_v2(db->handle);
+  err = js_get_callback_info(env, info, &argc, argv, NULL, (void **) &data);
+  assert(err == 0);
 
-  free(db);
+  assert(argc == 1);
+
+  bool result;
+  err = js_get_value_bool(env, argv[0], &result);
+  assert(err == 0);
+
+  data->status = result ? SQLITE_OK : SQLITE_DENY;
+
+  uv_sem_post(&data->done);
+
+  return NULL;
 }
 
 static void
-paraql__on_finalize_db(js_env_t *env, void *data, void *hint) {
+paraql__on_auth_call(js_env_t *env, js_value_t *on_auth, void *context, void *arg) {
   int err;
 
-  paraql_t *db = (paraql_t *) data;
+  paraql_t *db = (paraql_t *) context;
 
-  uv_loop_t *loop;
-  err = js_get_env_loop(env, &loop);
+  paraql_auth_t *data = (paraql_auth_t *) arg;
+
+  js_value_t *ctx;
+  err = js_get_reference_value(env, db->ctx, &ctx);
   assert(err == 0);
 
-  uv_work_t *handle = malloc(sizeof(uv_work_t));
+  js_value_t *args[6];
 
-  handle->data = (void *) db;
+  err = js_create_int32(env, data->action, &args[0]);
+  assert(err == 0);
 
-  err = uv_queue_work(loop, handle, paraql__on_before_finalize_db, paraql__on_after_finalize_db);
+  if (data->param1 != NULL) {
+    err = js_create_string_utf8(env, (utf8_t *) data->param1, -1, &args[1]);
+  } else {
+    err = js_get_null(env, &args[1]);
+  }
   assert(err == 0);
-}
 
-static void
-paraql__on_after_finalize_statement(uv_work_t *handle, int status) {
-  free(handle);
-}
+  if (data->param2 != NULL) {
+    err = js_create_string_utf8(env, (utf8_t *) data->param2, -1, &args[2]);
+  } else {
+    err = js_get_null(env, &args[2]);
+  }
+  assert(err == 0);
 
-static void
-paraql__on_before_finalize_statement(uv_work_t *handle) {
-  paraql_statement_t *stmt = (paraql_statement_t *) handle->data;
+  if (data->param3 != NULL) {
+    err = js_create_string_utf8(env, (utf8_t *) data->param3, -1, &args[3]);
+  } else {
+    err = js_get_null(env, &args[3]);
+  }
+  assert(err == 0);
 
-  if (stmt->handle != NULL) sqlite3_finalize(stmt->handle);
+  if (data->param4 != NULL) {
+    err = js_create_string_utf8(env, (utf8_t *) data->param4, -1, &args[4]);
+  } else {
+    err = js_get_null(env, &args[4]);
+  }
+  assert(err == 0);
 
-  paraql__remove_statement(stmt);
+  err = js_create_function(env, "done", -1, paraql__on_auth_done, (void *) data, &args[5]);
+  assert(err == 0);
 
-  free(stmt);
+  err = js_call_function(env, ctx, on_auth, 6, args, NULL);
+  assert(err == 0);
 }
 
-static void
-paraql__on_finalize_statement(js_env_t *env, void *data, void *hint) {
+int
+paraql__on_auth(void *context, int action, const char *param1, const char *param2, const char *param3, const char *param4) {
   int err;
 
-  paraql_statement_t *stmt = (paraql_statement_t *) data;
+  paraql_t *db = (paraql_t *) context;
 
-  uv_loop_t *loop;
-  err = js_get_env_loop(env, &loop);
+  paraql_auth_t data = {
+    action,
+    param1,
+    param2,
+    param3,
+    param4,
+  };
+
+  err = uv_sem_init(&data.done, 0);
   assert(err == 0);
 
-  uv_work_t *handle = malloc(sizeof(uv_work_t));
+  err = js_call_threadsafe_function(db->on_auth, (void *) &data, js_threadsafe_function_blocking);
+  assert(err == 0);
 
-  handle->data = stmt;
+  uv_sem_wait(&data.done);
 
-  err = uv_queue_work(loop, handle, paraql__on_before_finalize_statement, paraql__on_after_finalize_statement);
-  assert(err == 0);
+  uv_sem_destroy(&data.done);
+
+  return data.status;
 }
 
 static void
@@ -1241,13 +1259,16 @@ paraql__on_after_open(uv_work_t *handle, int status) {
     assert(err == 0);
   } else {
     js_value_t *result;
-    err = js_create_external(env, db, paraql__on_finalize_db, NULL, &result);
+    err = js_get_reference_value(env, req->ref, &result);
     assert(err == 0);
 
     err = js_resolve_deferred(env, req->deferred, result);
     assert(err == 0);
   }
 
+  err = js_delete_reference(env, req->ref);
+  assert(err == 0);
+
   err = js_close_handle_scope(env, scope);
   assert(err == 0);
 
@@ -1269,6 +1290,12 @@ paraql__on_before_open(uv_work_t *handle) {
     req->errmsg = errmsg;
 
     if (db->handle != NULL) sqlite3_close_v2(db->handle);
+
+    return;
+  }
+
+  if (db->on_auth != NULL) {
+    sqlite3_set_authorizer(db->handle, paraql__on_auth, (void *) db);
   }
 }
 
@@ -1276,29 +1303,47 @@ static js_value_t *
 paraql_open(js_env_t *env, js_callback_info_t *info) {
   int err;
 
-  size_t argc = 1;
-  js_value_t *argv[1];
+  size_t argc = 3;
+  js_value_t *argv[3];
 
   err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
   assert(err == 0);
 
-  assert(argc == 1);
+  assert(argc == 3);
 
   uv_loop_t *loop;
   err = js_get_env_loop(env, &loop);
   assert(err == 0);
 
+  js_value_t *handle;
+  paraql_t *db;
+  err = js_create_arraybuffer(env, sizeof(paraql_t), (void **) &db, &handle);
+
+  db->env = env;
+
+  err = js_create_reference(env, argv[0], 1, &db->ctx);
+  assert(err == 0);
+
   paraql_path_t name;
-  err = js_get_value_string_utf8(env, argv[0], name, sizeof(name), NULL);
+  err = js_get_value_string_utf8(env, argv[1], name, sizeof(name), NULL);
   assert(err == 0);
 
-  paraql_t *db = malloc(sizeof(paraql_t));
+  bool no_auth;
+  err = js_is_null(env, argv[2], &no_auth);
+  assert(err == 0);
 
-  db->env = env;
-  db->statements = NULL;
+  if (no_auth) {
+    db->on_auth = NULL;
+  } else {
+    err = js_create_threadsafe_function(env, argv[2], paraql__queue_limit, 1, NULL, NULL, (void *) db, paraql__on_auth_call, &db->on_auth);
+    assert(err == 0);
+  }
 
   paraql_open_t *req = malloc(sizeof(paraql_open_t));
 
+  err = js_create_reference(env, handle, 1, &req->ref);
+  assert(err == 0);
+
   req->db = db;
   req->errcode = 0;
   req->db->env = env;
@@ -1327,6 +1372,14 @@ paraql__on_after_close(uv_work_t *handle, int status) {
 
   js_env_t *env = db->env;
 
+  err = js_delete_reference(env, db->ctx);
+  assert(err == 0);
+
+  if (db->on_auth != NULL) {
+    err = js_release_threadsafe_function(db->on_auth, js_threadsafe_function_release);
+    assert(err == 0);
+  }
+
   js_handle_scope_t *scope;
   err = js_open_handle_scope(env, &scope);
   assert(err == 0);
@@ -1391,7 +1444,7 @@ paraql_close(js_env_t *env, js_callback_info_t *info) {
 
   req->errcode = 0;
 
-  err = js_get_value_external(env, argv[0], (void **) &req->db);
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &req->db, NULL);
   assert(err == 0);
 
   req->handle.data = (void *) req;
@@ -1503,7 +1556,7 @@ paraql_exec(js_env_t *env, js_callback_info_t *info) {
   assert(err == 0);
 
   paraql_t *db;
-  err = js_get_value_external(env, argv[0], (void **) &db);
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &db, NULL);
   assert(err == 0);
 
   size_t sql_len;
@@ -1545,8 +1598,6 @@ paraql__on_after_prepare(uv_work_t *handle, int status) {
 
   js_env_t *env = db->env;
 
-  paraql_statement_t *stmt = req->stmt;
-
   js_handle_scope_t *scope;
   err = js_open_handle_scope(env, &scope);
   assert(err == 0);
@@ -1560,13 +1611,16 @@ paraql__on_after_prepare(uv_work_t *handle, int status) {
     assert(err == 0);
   } else {
     js_value_t *result;
-    err = js_create_external(env, stmt, paraql__on_finalize_statement, NULL, &result);
+    err = js_get_reference_value(env, req->ref, &result);
     assert(err == 0);
 
     err = js_resolve_deferred(env, req->deferred, result);
     assert(err == 0);
   }
 
+  err = js_delete_reference(env, req->ref);
+  assert(err == 0);
+
   err = js_close_handle_scope(env, scope);
   assert(err == 0);
 
@@ -1579,7 +1633,7 @@ paraql__on_before_prepare(uv_work_t *handle) {
 
   paraql_t *db = req->db;
 
-  paraql_statement_t *stmt = malloc(sizeof(paraql_statement_t));
+  paraql_statement_t *stmt = req->stmt;
 
   int status = sqlite3_prepare_v2(db->handle, (const char *) req->sql, -1, &stmt->handle, NULL);
 
@@ -1590,13 +1644,7 @@ paraql__on_before_prepare(uv_work_t *handle) {
     req->errmsg = sqlite3_errmsg(db->handle);
 
     if (stmt->handle != NULL) sqlite3_finalize(stmt->handle);
-
-    return;
   }
-
-  paraql__insert_statement(db, stmt);
-
-  req->stmt = stmt;
 }
 
 static js_value_t *
@@ -1616,7 +1664,7 @@ paraql_prepare(js_env_t *env, js_callback_info_t *info) {
   assert(err == 0);
 
   paraql_t *db;
-  err = js_get_value_external(env, argv[0], (void **) &db);
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &db, NULL);
   assert(err == 0);
 
   size_t sql_len;
@@ -1632,9 +1680,17 @@ paraql_prepare(js_env_t *env, js_callback_info_t *info) {
 
   paraql_prepare_t *req = malloc(sizeof(paraql_prepare_t));
 
+  js_value_t *handle;
+  err = js_create_arraybuffer(env, sizeof(paraql_statement_t), (void **) &req->stmt, &handle);
+  assert(err == 0);
+
+  err = js_create_reference(env, handle, 1, &req->ref);
+  assert(err == 0);
+
   req->errcode = 0;
   req->db = db;
   req->sql = sql;
+  req->stmt->db = db;
 
   req->handle.data = (void *) req;
 
@@ -1683,8 +1739,6 @@ paraql__on_before_finalize(uv_work_t *handle) {
     sqlite3_finalize(stmt->handle);
     stmt->handle = NULL;
   }
-
-  paraql__remove_statement(stmt);
 }
 
 static js_value_t *
@@ -1704,7 +1758,7 @@ paraql_finalize(js_env_t *env, js_callback_info_t *info) {
   assert(err == 0);
 
   paraql_statement_t *stmt;
-  err = js_get_value_external(env, argv[0], (void **) &stmt);
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &stmt, NULL);
   assert(err == 0);
 
   paraql_finalize_t *req = malloc(sizeof(paraql_finalize_t));
@@ -1790,7 +1844,7 @@ paraql_reset(js_env_t *env, js_callback_info_t *info) {
   assert(err == 0);
 
   paraql_statement_t *stmt;
-  err = js_get_value_external(env, argv[0], (void **) &stmt);
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &stmt, NULL);
   assert(err == 0);
 
   paraql_reset_t *req = malloc(sizeof(paraql_reset_t));
@@ -2279,7 +2333,7 @@ paraql_bind(js_env_t *env, js_callback_info_t *info) {
   assert(err == 0);
 
   paraql_statement_t *stmt;
-  err = js_get_value_external(env, argv[0], (void **) &stmt);
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &stmt, NULL);
   assert(err == 0);
 
   js_ref_t *named;
@@ -2480,7 +2534,7 @@ paraql_step(js_env_t *env, js_callback_info_t *info) {
   assert(err == 0);
 
   paraql_statement_t *stmt;
-  err = js_get_value_external(env, argv[0], (void **) &stmt);
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &stmt, NULL);
   assert(err == 0);
 
   paraql_step_t *req = malloc(sizeof(paraql_step_t));
@@ -2592,7 +2646,7 @@ paraql_run(js_env_t *env, js_callback_info_t *info) {
   assert(err == 0);
 
   paraql_statement_t *stmt;
-  err = js_get_value_external(env, argv[0], (void **) &stmt);
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &stmt, NULL);
   assert(err == 0);
 
   paraql_run_t *req = malloc(sizeof(paraql_run_t));
@@ -2613,6 +2667,111 @@ paraql_run(js_env_t *env, js_callback_info_t *info) {
   return promise;
 }
 
+static void
+paraql__on_finalize_serialized(js_env_t *env, void *data, void *hint) {
+  sqlite3_free(data);
+}
+
+static void
+paraql__on_after_serialize(uv_work_t *handle, int status) {
+  int err;
+
+  paraql_serialize_t *req = (paraql_serialize_t *) handle->data;
+
+  js_env_t *env = req->env;
+
+  js_handle_scope_t *scope;
+  err = js_open_handle_scope(env, &scope);
+  assert(err == 0);
+
+  if (req->errcode) {
+    js_value_t *error;
+    err = paraql__make_error(env, req->errcode, req->errmsg, &error);
+    assert(err == 0);
+
+    err = js_reject_deferred(env, req->deferred, error);
+    assert(err == 0);
+  } else {
+    if (req->size > 0) {
+      js_value_t *result;
+      err = js_create_external_arraybuffer(env, (void *) req->data, (size_t) req->size, paraql__on_finalize_serialized, NULL, &result);
+      assert(err == 0);
+
+      err = js_resolve_deferred(env, req->deferred, result);
+      assert(err == 0);
+    } else {
+      js_value_t *result;
+      err = js_create_arraybuffer(env, 0, NULL, &result);
+      assert(err == 0);
+
+      err = js_resolve_deferred(env, req->deferred, result);
+      assert(err == 0);
+    }
+  }
+
+  err = js_close_handle_scope(env, scope);
+  assert(err == 0);
+
+  free(req);
+}
+
+static void
+paraql__on_before_serialize(uv_work_t *handle) {
+  paraql_serialize_t *req = (paraql_serialize_t *) handle->data;
+
+  paraql_t *db = req->db;
+
+  sqlite3_int64 size = 0;
+  req->data = sqlite3_serialize(db->handle, "main", &size, 0);
+
+  if (req->data == NULL && size != 0) {
+    req->errcode = sqlite3_extended_errcode(db->handle);
+    req->errmsg = sqlite3_errmsg(db->handle);
+
+    return;
+  }
+
+  req->size = size;
+}
+
+static js_value_t *
+paraql_serialize(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 1;
+  js_value_t *argv[1];
+
+  err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
+  assert(err == 0);
+
+  assert(argc == 1);
+
+  uv_loop_t *loop;
+  err = js_get_env_loop(env, &loop);
+  assert(err == 0);
+
+  paraql_t *db;
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &db, NULL);
+  assert(err == 0);
+
+  paraql_serialize_t *req = malloc(sizeof(paraql_serialize_t));
+
+  req->errcode = 0;
+  req->env = env;
+  req->db = db;
+
+  req->handle.data = (void *) req;
+
+  js_value_t *promise;
+  err = js_create_promise(env, &req->deferred, &promise);
+  assert(err == 0);
+
+  err = uv_queue_work(loop, &req->handle, paraql__on_before_serialize, paraql__on_after_serialize);
+  assert(err == 0);
+
+  return promise;
+}
+
 static js_value_t *
 paraql_exports(js_env_t *env, js_value_t *exports) {
   int err;
@@ -2638,6 +2797,7 @@ paraql_exports(js_env_t *env, js_value_t *exports) {
   V("bind", paraql_bind)
   V("step", paraql_step)
   V("run", paraql_run)
+  V("serialize", paraql_serialize)
 #undef V
 
   return exports;