auto-convert types by convention

Author: typesafe

README.md

@@ -2,7 +2,9 @@ The `node-api` Zig package provides [Node-API](https://nodejs.org/api/n-api.html
 
 TODO:
 
+
 - [ ] Add GH pipeline (incl. test report)
+- [ ] auto-register class for members of type `type`.
 - [ ] Make `NodeFunction` thread safe by convention when it is used in an async function/method.
 - [ ] Add `NodeObject` for "by reference" access to JS objects from Zig
 - [ ] Add `NodeArray` for "by reference" access to JS objects from Zig

src/Serializer.zig

@@ -3,19 +3,23 @@ const lib = @import("c.zig");
 const c = lib.c;
 const s2e = lib.statusToError;
 const node_values = @import("node_values.zig");
-
+const NodeContext = @import("Node.zig").NodeContext;
 const NodeValue = node_values.NodeValue;
 const NodeObject = node_values.NodeObject;
 const NodeArray = node_values.NodeArray;
 const NodeFunction = node_values.NodeFunction;
 const registry = @import("references.zig").Registry;
+
 /// Converts a Zig value to a Node-API value. Memory for the node value is allocated by V8.
 pub fn serialize(env: c.napi_env, value: anytype) !c.napi_value {
     const T = @TypeOf(value);
 
+    const node = NodeContext.init(env);
     var res: c.napi_value = undefined;
 
     switch (@typeInfo(T)) {
+        .type => return (try node.defineClass(value)).napi_value,
+        .@"fn" => return (try node.defineFunction(value)).napi_value,
         .null => try s2e(c.napi_get_null(env, &res)),
         .void, .undefined => try s2e(c.napi_get_undefined(env, &res)),
         .bool => try s2e(c.napi_get_boolean(env, value, &res)),

tests/node_modules/node-api-test-module/zig-module.node

@@ -5,6 +5,11 @@ describe("wrapInstance", () => {
   it("should wrap instance", () => {
     expect(addon.wrappedInstance).toBeObject();
   });
+  it("should wrap by convention", () => {
+    expect(addon.wrappedByConvention).toBeObject();
+    addon.wrappedByConvention.foo = 456;
+    expect(addon.wrappedByConvention.foo).toEqual(456);
+  });
   it("should wrap fields", () => {
     console.log(addon.wrappedInstance);
     expect(addon.wrappedInstance.foo).toEqual(123);

tests/wrap.spec.ts

@@ -5,26 +5,26 @@ const TestClass = @import("TestClass.zig");
 
 const WrapTarget = @import("WrapTarget.zig");
 const Serialization = @import("Serialization.zig");
+
 comptime {
     node_api.register(init);
 }
 
 fn init(node: node_api.NodeContext) !?node_api.NodeValue {
-    // const i = getInt();
-    // const ui = getUInt();
-    // const b = try node.deserialize(bool, try node.serialize(true));
-
-    // const ;
+    const ptr = try std.heap.c_allocator.create(WrapTarget);
+    ptr.* = .{ .foo = 123, .bar = "hopla" };
 
-    const v = try node.serialize(.{
-        .serialization = try node.defineClass(Serialization),
-        .TestClass = try node.defineClass(TestClass),
+    return try node.serialize(.{
+        .serialization = Serialization,
+        .TestClass = TestClass,
         .wrappedInstance = try node.wrapInstance(WrapTarget, .{ .foo = 123, .bar = "hopla" }),
+        .wrappedByConvention = ptr,
         .functions = .{
-            .fnWithJsNewedNativeInstance = try node.defineFunction(fnWithJsNewedNativeInstance),
-            .fnWithSerializedParams = try node.defineFunction(fnWithSerializedParams),
+            .fnWithJsNewedNativeInstance = fnWithJsNewedNativeInstance,
+            .fnWithSerializedParams = fnWithSerializedParams,
             .fnWithAllocatorParam = try node.defineFunction(fnWithAllocatorParam),
             .fnCallback = try node.defineFunction(fnCallback),
+            // async must still be done explicitly
             .fnCallbackAsync = try node.defineAsyncFunction(fnCallbackAsync),
             .asyncFunction = try node.defineAsyncFunction(sleep),
         },
@@ -35,24 +35,7 @@ fn init(node: node_api.NodeContext) !?node_api.NodeValue {
             .comptime_int = try node.deserialize(i32, try node.serialize(1234)),
             .float = try node.deserialize(f32, try node.serialize(12.34)),
         },
-        // .s = s,
-        // .x = x,
-        // .b = b,
-        // .foo = "foo",
-        // .bar = "bar",
-        // .int = 123,
-        // .f = 12.34,
-        // .i = i,
-        // .ui = ui,
-        // .nested = .{ .more = "foo" },
-        // .callMet = try node.createFunction(),
     });
-
-    // const v = try node.serialize(.{
-    //     .fun = try node.createFunc(testFuncNative2),
-    // });
-
-    return v;
 }
 
 fn getInt() i16 {