@pbwire/pbwire 0.1.7 → 0.1.8

package/README.md

@@ -208,13 +208,31 @@ per-message finalizer.
 - **No protoc plugin / code generation.** The schema is always loaded at run
   time, like the Python binding: a `FileDescriptorSet` is the only schema
   source, and there is no generated layout to keep in sync.
-- **No conformance testee.** The official suite is covered through the C core
-  and `conformance/`, not through this binding. The differential test above is
-  what keeps the addon's wire reader honest against the core's.
+Also exported: JSON/text format (`messageToJson`/`jsonToMessage` — the latter
+with an optional ignore-unknown flag, `messageToText`/`textToMessage` — the
+former with an optional print-unknown flag), field presence (`has`), and
+delimited framing (`encodeDelimited`/`decodeDelimited`, returning
+`{message, read}` so concatenated frames decode in a loop).
+See `test/test_pbwire.js`.
 
-Also out of scope here: JSON/text format (`pbw_json_print`/`pbw_text_print`),
-field presence introspection (`pbw_message_field_count`), and delimited framing.
-Each is one addon export away when a consumer needs it.
+## Conformance
+
+`conformance/testee.js` drives the official `conformance_test_runner`
+through this binding (`make conformance-node`):
+
+```
+CONFORMANCE SUITE PASSED: 2742 successes, 0 skipped, 2 expected failures,
+0 unexpected failures.
+CONFORMANCE SUITE PASSED: 445 successes, 0 skipped, 0 expected failures,
+0 unexpected failures.
+```
+
+Binary input decodes to a tree (unknown fields survive, oneof collapses to
+the last member) and every output renders that same tree; JSON input with
+unknown fields only parses when the test category asks to ignore them, and
+text output honors the runner's `print_unknown_fields` flag. The 2 expected
+failures are the shared `conformance/failure_list_pbwire.txt` (tag varints
+the reference C++ testee truncates identically); only JSPB answers `skipped`.
 
 ## Generated models
 

package/lib/pbwire.js

@@ -107,6 +107,40 @@ class MessageType {
     return this._copy(addon.encodeObject(this._handle, value));
   }
 
+  /** Parse JSON mapping text into a Message; throws on malformed input.
+   * A second true argument skips unknown field names instead of failing. */
+  fromJson(json, ignore = false) {
+    if (typeof json !== 'string') {
+      throw new TypeError('pbwire: fromJson expects a string');
+    }
+    const message = new Message(this);
+    message._handle = addon.jsonToMessage(this._handle, json, ignore);
+    return message;
+  }
+
+  /** Parse text format into a Message; throws on malformed input. */
+  fromText(text) {
+    if (typeof text !== 'string') {
+      throw new TypeError('pbwire: fromText expects a string');
+    }
+    const message = new Message(this);
+    message._handle = addon.textToMessage(this._handle, text);
+    return message;
+  }
+
+  /** Decode one length-delimited frame: {message, read}, where read counts
+   * the length prefix plus the frame, so concatenated frames decode in a
+   * loop. Throws on a truncated frame. */
+  decodeDelimited(bytes) {
+    if (!Buffer.isBuffer(bytes)) {
+      throw new TypeError('pbwire: decodeDelimited expects a Buffer');
+    }
+    const res = addon.decodeDelimited(this._handle, bytes);
+    const message = new Message(this);
+    message._handle = res.message;
+    return { message, read: res.read };
+  }
+
   /** Decode wire bytes into a Message; throws on malformed input. */
   decode(bytes) {
     if (!Buffer.isBuffer(bytes)) {
@@ -152,6 +186,12 @@ class Message {
 
   /** Store a field value by name; `undefined`/`null` clears the field. */
   set(name, value) {
+    addon.set(this._tree(), name, value);
+    return this;
+  }
+
+  /** The mutable tree, decoding the retained bytes once when needed. */
+  _tree() {
     this._live();
     if (this._wire !== null) {
       // Writing needs a mutable tree: decode the retained bytes once.
@@ -159,8 +199,28 @@ class Message {
       this._wire = null;
       this._slices = null;
     }
-    addon.set(this._handle, name, value);
-    return this;
+    return this._handle;
+  }
+
+  /** JSON mapping text of this message. */
+  toJson() {
+    return addon.messageToJson(this._tree());
+  }
+
+  /** Protobuf text format of this message; a false argument drops unknown
+   * fields instead of printing them numerically. */
+  toText(printUnknown = true) {
+    return addon.messageToText(this._tree(), printUnknown);
+  }
+
+  /** Field presence by name: set (even to a zero) reads true. */
+  has(name) {
+    return addon.has(this._tree(), name);
+  }
+
+  /** One length-delimited frame (varint length + message). */
+  encodeDelimited() {
+    return addon.encodeDelimited(this._tree());
   }
 
   /** Wire bytes of this message. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pbwire/pbwire",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "Dynamic protobuf over the pbwire C ABI, schema at runtime, no generated code",
   "license": "Apache-2.0",
   "repository": {

package/runtime/addon.c

@@ -2528,6 +2528,279 @@ message_free(napi_env env, napi_callback_info info)
     return out;
 }
 
+/* JSON text of a tree (protobuf JSON mapping). */
+static napi_value
+message_to_json(napi_env env, napi_callback_info info)
+{
+    napi_value argv[1];
+    napi_value out = NULL;
+    message_handle *handle;
+    char *text = NULL;
+    size_t len = 0;
+    pbw_status status;
+
+    if (!get_args(env, info, argv, 1)) {
+        return NULL;
+    }
+    if (!unwrap_message(env, argv[0], &handle)) {
+        return NULL;
+    }
+    status = pbw_json_print(handle->msg, &text, &len);
+    if (status != PBW_OK) {
+        return fail_status(env, "messageToJson", status);
+    }
+    if (napi_create_string_utf8(env, text, len, &out) != napi_ok) {
+        pbw_free(text);
+        return NULL;
+    }
+    pbw_free(text);
+    return out;
+}
+
+/* Parses JSON mapping text into a new tree; an optional third boolean
+ * argument skips unknown field names instead of failing. */
+static napi_value
+json_to_message(napi_env env, napi_callback_info info)
+{
+    napi_value argv[3];
+    size_t argc = 3;
+    desc_handle *desc;
+    message_handle *handle;
+    pbw_message *msg = NULL;
+    string_buf buf;
+    const char *text;
+    pbw_status status;
+    pbw_json_parse_options opts;
+    bool ignore = false;
+
+    if (napi_get_cb_info(env, info, &argc, argv, NULL, NULL) != napi_ok ||
+        argc < 2) {
+        napi_throw_type_error(env, NULL, "pbwire: expected (desc, json)");
+        return NULL;
+    }
+    if (!unwrap(env, argv[0], (void **)&desc, "message descriptor handle")) {
+        return NULL;
+    }
+    if (argc > 2) {
+        napi_valuetype want = napi_undefined;
+
+        if (napi_typeof(env, argv[2], &want) != napi_ok ||
+            want != napi_boolean ||
+            napi_get_value_bool(env, argv[2], &ignore) != napi_ok) {
+            napi_throw_type_error(env, NULL,
+                                  "pbwire: ignore flag must be a boolean");
+            return NULL;
+        }
+    }
+    text = string_bytes(env, argv[1], &buf);
+    if (text == NULL) {
+        return NULL;
+    }
+    opts.ignore_unknown_fields = ignore;
+    status = pbw_json_parse_opts(desc->table->desc, text, buf.len, &opts,
+                                 &msg);
+    string_free(&buf, text);
+    if (status != PBW_OK) {
+        return fail_status(env, "jsonToMessage", status);
+    }
+    handle = calloc(1, sizeof(*handle));
+    if (handle == NULL) {
+        pbw_message_free(msg);
+        return fail_memory(env);
+    }
+    handle->msg = msg;
+    return new_message_value(env, desc, argv[0], handle);
+}
+
+/* Text format of a tree. */
+static napi_value
+message_to_text(napi_env env, napi_callback_info info)
+{
+    napi_value argv[2];
+    size_t argc = 2;
+    napi_value out = NULL;
+    message_handle *handle;
+    char *text = NULL;
+    size_t len = 0;
+    pbw_status status;
+    /* Absent means print (the binding's standing behavior); the testee
+     * passes the runner's print_unknown_fields flag explicitly. */
+    bool print_unknown = true;
+
+    if (napi_get_cb_info(env, info, &argc, argv, NULL, NULL) != napi_ok ||
+        argc < 1) {
+        napi_throw_type_error(env, NULL, "pbwire: expected (message)");
+        return NULL;
+    }
+    if (!unwrap_message(env, argv[0], &handle)) {
+        return NULL;
+    }
+    if (argc > 1) {
+        napi_valuetype want = napi_undefined;
+
+        if (napi_typeof(env, argv[1], &want) != napi_ok ||
+            want != napi_boolean ||
+            napi_get_value_bool(env, argv[1], &print_unknown) != napi_ok) {
+            napi_throw_type_error(env, NULL,
+                                  "pbwire: print flag must be a boolean");
+            return NULL;
+        }
+    }
+    status = pbw_text_print_opts(handle->msg, print_unknown, &text, &len);
+    if (status != PBW_OK) {
+        return fail_status(env, "messageToText", status);
+    }
+    if (napi_create_string_utf8(env, text, len, &out) != napi_ok) {
+        pbw_free(text);
+        return NULL;
+    }
+    pbw_free(text);
+    return out;
+}
+
+/* Parses text format into a new tree. */
+static napi_value
+text_to_message(napi_env env, napi_callback_info info)
+{
+    napi_value argv[2];
+    desc_handle *desc;
+    message_handle *handle;
+    pbw_message *msg = NULL;
+    string_buf buf;
+    const char *text;
+    pbw_status status;
+
+    if (!get_args(env, info, argv, 2)) {
+        return NULL;
+    }
+    if (!unwrap(env, argv[0], (void **)&desc, "message descriptor handle")) {
+        return NULL;
+    }
+    text = string_bytes(env, argv[1], &buf);
+    if (text == NULL) {
+        return NULL;
+    }
+    status = pbw_text_parse(desc->table->desc, text, buf.len, &msg);
+    string_free(&buf, text);
+    if (status != PBW_OK) {
+        return fail_status(env, "textToMessage", status);
+    }
+    handle = calloc(1, sizeof(*handle));
+    if (handle == NULL) {
+        pbw_message_free(msg);
+        return fail_memory(env);
+    }
+    handle->msg = msg;
+    return new_message_value(env, desc, argv[0], handle);
+}
+
+/* Presence of one field by name: set (even to a zero) reads true. */
+static napi_value
+message_has(napi_env env, napi_callback_info info)
+{
+    napi_value argv[2];
+    napi_value out = NULL;
+    message_handle *handle;
+    field_entry *entry;
+    int present;
+
+    if (!get_args(env, info, argv, 2)) {
+        return NULL;
+    }
+    if (!unwrap_message(env, argv[0], &handle)) {
+        return NULL;
+    }
+    entry = field_by_name(env, handle, argv[1]);
+    if (entry == NULL) {
+        return NULL;
+    }
+    present = pbw_message_get_field(handle->msg, entry->field) != NULL;
+    if (napi_get_boolean(env, present, &out) != napi_ok) {
+        return NULL;
+    }
+    return out;
+}
+
+/* One length-delimited frame (varint length + message) as a Buffer. */
+static napi_value
+encode_delimited(napi_env env, napi_callback_info info)
+{
+    napi_value argv[1];
+    napi_value out = NULL;
+    message_handle *handle;
+    uint8_t *wire = NULL;
+    size_t wire_len = 0;
+    pbw_status status;
+
+    if (!get_args(env, info, argv, 1)) {
+        return NULL;
+    }
+    if (!unwrap_message(env, argv[0], &handle)) {
+        return NULL;
+    }
+    status = pbw_encode_delimited(handle->msg, &wire, &wire_len);
+    if (status != PBW_OK) {
+        return fail_status(env, "encodeDelimited", status);
+    }
+    if (napi_create_buffer_copy(env, wire_len, wire, NULL, &out) != napi_ok) {
+        pbw_free(wire);
+        return NULL;
+    }
+    pbw_free(wire);
+    return out;
+}
+
+/* One frame from a Buffer: {message, read}, where read counts the length
+ * prefix plus the frame, so concatenated frames decode in a loop. */
+static napi_value
+decode_delimited(napi_env env, napi_callback_info info)
+{
+    napi_value argv[2];
+    napi_value out = NULL;
+    napi_value message_value = NULL;
+    napi_value read_value = NULL;
+    desc_handle *desc;
+    message_handle *handle;
+    pbw_message *msg = NULL;
+    void *data = NULL;
+    size_t len = 0;
+    size_t consumed = 0;
+    pbw_status status;
+
+    if (!get_args(env, info, argv, 2)) {
+        return NULL;
+    }
+    if (!unwrap(env, argv[0], (void **)&desc, "message descriptor handle")) {
+        return NULL;
+    }
+    if (napi_get_buffer_info(env, argv[1], &data, &len) != napi_ok) {
+        return fail_argument(env, "decodeDelimited expects a Buffer");
+    }
+    status = pbw_decode_delimited(desc->table->desc, data, len, &msg,
+                                  &consumed);
+    if (status != PBW_OK) {
+        return fail_status(env, "decodeDelimited", status);
+    }
+    handle = calloc(1, sizeof(*handle));
+    if (handle == NULL) {
+        pbw_message_free(msg);
+        return fail_memory(env);
+    }
+    handle->msg = msg;
+    message_value = new_message_value(env, desc, argv[0], handle);
+    if (message_value == NULL) {
+        return NULL;
+    }
+    if (napi_create_object(env, &out) != napi_ok ||
+        napi_set_named_property(env, out, "message", message_value) !=
+            napi_ok ||
+        napi_create_uint32(env, (uint32_t)consumed, &read_value) != napi_ok ||
+        napi_set_named_property(env, out, "read", read_value) != napi_ok) {
+        return NULL;
+    }
+    return out;
+}
+
 NAPI_MODULE_INIT()
 {
     napi_property_descriptor properties[] = {
@@ -2554,6 +2827,19 @@ NAPI_MODULE_INIT()
         {"copyEncoded", NULL, copy_encoded, NULL, NULL, NULL, napi_enumerable,
          NULL},
         {"free", NULL, message_free, NULL, NULL, NULL, napi_enumerable, NULL},
+        {"messageToJson", NULL, message_to_json, NULL, NULL, NULL,
+         napi_enumerable, NULL},
+        {"jsonToMessage", NULL, json_to_message, NULL, NULL, NULL,
+         napi_enumerable, NULL},
+        {"messageToText", NULL, message_to_text, NULL, NULL, NULL,
+         napi_enumerable, NULL},
+        {"textToMessage", NULL, text_to_message, NULL, NULL, NULL,
+         napi_enumerable, NULL},
+        {"has", NULL, message_has, NULL, NULL, NULL, napi_enumerable, NULL},
+        {"encodeDelimited", NULL, encode_delimited, NULL, NULL, NULL,
+         napi_enumerable, NULL},
+        {"decodeDelimited", NULL, decode_delimited, NULL, NULL, NULL,
+         napi_enumerable, NULL},
     };
 
     if (napi_define_properties(env, exports,