nodenetcdf 4.9.3 → 4.9.32

package/src/Dimension.cpp

@@ -25,6 +25,7 @@ void Dimension::Init(v8::Local<v8::Object> exports)
     tpl->SetClassName(v8::String::NewFromUtf8(isolate, "Dimension", v8::NewStringType::kNormal).ToLocalChecked());
     tpl->InstanceTemplate()->SetInternalFieldCount(1);
     NODE_SET_PROTOTYPE_METHOD(tpl, "inspect", Dimension::Inspect);
+    NODE_SET_PROTOTYPE_METHOD(tpl, "toJSON", Dimension::ToJSON);
     tpl->InstanceTemplate()->SetAccessor(
         v8::String::NewFromUtf8(isolate, "id", v8::NewStringType::kNormal).ToLocalChecked(), Dimension::GetId);
     tpl->InstanceTemplate()->SetAccessor(
@@ -102,4 +103,39 @@ void Dimension::Inspect(const v8::FunctionCallbackInfo<v8::Value> &args)
     args.GetReturnValue().Set(
         v8::String::NewFromUtf8(isolate, "[object Dimension]", v8::NewStringType::kNormal).ToLocalChecked());
 }
+
+void Dimension::ToJSON(const v8::FunctionCallbackInfo<v8::Value> &args)
+{
+    v8::Isolate *isolate = args.GetIsolate();
+    v8::Local<v8::Context> context = isolate->GetCurrentContext();
+    const auto *obj = node::ObjectWrap::Unwrap<Dimension>(args.Holder());
+    
+    // Use internalized strings for better performance
+    v8::Local<v8::String> id_str = v8::String::NewFromUtf8Literal(isolate, "id");
+    v8::Local<v8::String> name_str = v8::String::NewFromUtf8Literal(isolate, "name");
+    v8::Local<v8::String> length_str = v8::String::NewFromUtf8Literal(isolate, "length");
+    
+    v8::Local<v8::Object> json = v8::Object::New(isolate);
+    
+    // Add id
+    (void)json->CreateDataProperty(context, id_str, v8::Integer::New(isolate, obj->id));
+    
+    // Add name
+    std::array<char, NC_MAX_NAME + 1> name{};
+    if (obj->get_name(name.data()))
+    {
+        (void)json->CreateDataProperty(context, name_str,
+                  v8::String::NewFromUtf8(isolate, name.data(), v8::NewStringType::kInternalized).ToLocalChecked());
+    }
+    
+    // Add length
+    size_t len = 0;
+    const int retval = nc_inq_dimlen(obj->parent_id, obj->id, &len);
+    if (retval == NC_NOERR)
+    {
+        (void)json->CreateDataProperty(context, length_str, v8::Integer::New(isolate, static_cast<int32_t>(len)));
+    }
+    
+    args.GetReturnValue().Set(json);
+}
 } // namespace nodenetcdfjs

package/src/Dimension.h

@@ -30,6 +30,7 @@ class Dimension : public node::ObjectWrap
     static void SetName(v8::Local<v8::String> property, v8::Local<v8::Value> val,
                         const v8::PropertyCallbackInfo<void> &info);
     static void Inspect(const v8::FunctionCallbackInfo<v8::Value> &args);
+    static void ToJSON(const v8::FunctionCallbackInfo<v8::Value> &args);
 
     int id{-1};
     int parent_id{-1};

package/src/File.cpp

@@ -38,6 +38,7 @@ void File::Init(v8::Local<v8::Object> exports)
     NODE_SET_PROTOTYPE_METHOD(tpl, "sync", File::Sync);
     NODE_SET_PROTOTYPE_METHOD(tpl, "close", File::Close);
     NODE_SET_PROTOTYPE_METHOD(tpl, "inspect", File::Inspect);
+    NODE_SET_PROTOTYPE_METHOD(tpl, "toJSON", File::ToJSON);
     constructor.Reset(isolate, tpl->GetFunction(isolate->GetCurrentContext()).ToLocalChecked());
     exports->Set(isolate->GetCurrentContext(),
                  v8::String::NewFromUtf8(isolate, "File", v8::NewStringType::kNormal).ToLocalChecked(),
@@ -167,4 +168,17 @@ void File::Inspect(const v8::FunctionCallbackInfo<v8::Value> &args)
     args.GetReturnValue().Set(
         v8::String::NewFromUtf8(isolate, "[object File]", v8::NewStringType::kNormal).ToLocalChecked());
 }
+
+void File::ToJSON(const v8::FunctionCallbackInfo<v8::Value> &args)
+{
+    v8::Isolate *isolate = args.GetIsolate();
+    v8::Local<v8::Context> context = isolate->GetCurrentContext();
+    
+    // Get the root group and serialize it
+    v8::Local<v8::String> rootProp = v8::String::NewFromUtf8(isolate, "root", v8::NewStringType::kNormal).ToLocalChecked();
+    v8::Local<v8::Value> root = args.Holder()->Get(context, rootProp).ToLocalChecked();
+    
+    // The root group's toJSON will automatically serialize all children recursively
+    args.GetReturnValue().Set(root);
+}
 } // namespace nodenetcdfjs

package/src/File.h

@@ -30,6 +30,7 @@ class File : public node::ObjectWrap
     static void Close(const v8::FunctionCallbackInfo<v8::Value> &args);
     static void Sync(const v8::FunctionCallbackInfo<v8::Value> &args);
     static void Inspect(const v8::FunctionCallbackInfo<v8::Value> &args);
+    static void ToJSON(const v8::FunctionCallbackInfo<v8::Value> &args);
 
     static v8::Persistent<v8::Function> constructor;
 

package/src/Group.cpp

@@ -31,6 +31,7 @@ void Group::Init(v8::Local<v8::Object> exports)
     NODE_SET_PROTOTYPE_METHOD(tpl, "addSubgroup", Group::AddSubgroup);
     NODE_SET_PROTOTYPE_METHOD(tpl, "addAttribute", Group::AddAttribute);
     NODE_SET_PROTOTYPE_METHOD(tpl, "inspect", Group::Inspect);
+    NODE_SET_PROTOTYPE_METHOD(tpl, "toJSON", Group::ToJSON);
     tpl->InstanceTemplate()->SetAccessor(
         v8::String::NewFromUtf8(isolate, "id", v8::NewStringType::kNormal).ToLocalChecked(), Group::GetId);
     tpl->InstanceTemplate()->SetAccessor(
@@ -244,6 +245,7 @@ void Group::GetId(v8::Local<v8::String> property, const v8::PropertyCallbackInfo
 void Group::GetVariables(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value> &info)
 {
     v8::Isolate *isolate = info.GetIsolate();
+    v8::Local<v8::Context> context = isolate->GetCurrentContext();
     const auto *obj = node::ObjectWrap::Unwrap<Group>(info.Holder());
 
     int nvars = 0;
@@ -270,8 +272,8 @@ void Group::GetVariables(v8::Local<v8::String> property, const v8::PropertyCallb
         auto *v = new Variable(var_ids[i], obj->id);
         if (v->get_name(name.data()))
         {
-            result->Set(isolate->GetCurrentContext(),
-                        v8::String::NewFromUtf8(isolate, name.data(), v8::NewStringType::kNormal).ToLocalChecked(),
+            (void)result->CreateDataProperty(context,
+                        v8::String::NewFromUtf8(isolate, name.data(), v8::NewStringType::kInternalized).ToLocalChecked(),
                         v->handle());
         }
         else
@@ -285,6 +287,7 @@ void Group::GetVariables(v8::Local<v8::String> property, const v8::PropertyCallb
 void Group::GetDimensions(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value> &info)
 {
     v8::Isolate *isolate = info.GetIsolate();
+    v8::Local<v8::Context> context = isolate->GetCurrentContext();
     const auto *obj = node::ObjectWrap::Unwrap<Group>(info.Holder());
 
     int ndims = 0;
@@ -311,10 +314,8 @@ void Group::GetDimensions(v8::Local<v8::String> property, const v8::PropertyCall
         auto *d = new Dimension(dim_ids[i], obj->id);
         if (d->get_name(name.data()))
         {
-            // Suppress warning about unused return value
-            (void)result->Set(
-                isolate->GetCurrentContext(),
-                v8::String::NewFromUtf8(isolate, name.data(), v8::NewStringType::kNormal).ToLocalChecked(),
+            (void)result->CreateDataProperty(context,
+                v8::String::NewFromUtf8(isolate, name.data(), v8::NewStringType::kInternalized).ToLocalChecked(),
                 d->handle());
         }
         else
@@ -326,6 +327,7 @@ void Group::GetDimensions(v8::Local<v8::String> property, const v8::PropertyCall
 void Group::GetUnlimited(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value> &info)
 {
     v8::Isolate *isolate = info.GetIsolate();
+    v8::Local<v8::Context> context = isolate->GetCurrentContext();
     const auto *obj = node::ObjectWrap::Unwrap<Group>(info.Holder());
 
     int ndims = 0;
@@ -352,9 +354,8 @@ void Group::GetUnlimited(v8::Local<v8::String> property, const v8::PropertyCallb
         auto *d = new Dimension(dim_ids[i], obj->id);
         if (d->get_name(name.data()))
         {
-             // Suppress warning about unused return value
-             (void)result->Set(isolate->GetCurrentContext(),
-                        v8::String::NewFromUtf8(isolate, name.data(), v8::NewStringType::kNormal).ToLocalChecked(),
+             (void)result->CreateDataProperty(context,
+                        v8::String::NewFromUtf8(isolate, name.data(), v8::NewStringType::kInternalized).ToLocalChecked(),
                         d->handle());
         }
         else return;
@@ -365,6 +366,7 @@ void Group::GetUnlimited(v8::Local<v8::String> property, const v8::PropertyCallb
 void Group::GetAttributes(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value> &info)
 {
     v8::Isolate *isolate = info.GetIsolate();
+    v8::Local<v8::Context> context = isolate->GetCurrentContext();
     const auto *obj = node::ObjectWrap::Unwrap<Group>(info.Holder());
 
     int natts = 0;
@@ -387,8 +389,8 @@ void Group::GetAttributes(v8::Local<v8::String> property, const v8::PropertyCall
             return;
         }
         auto *a = new Attribute(name.data(), NC_GLOBAL, obj->id);
-        result->Set(isolate->GetCurrentContext(),
-                    v8::String::NewFromUtf8(isolate, name.data(), v8::NewStringType::kNormal).ToLocalChecked(),
+        (void)result->CreateDataProperty(context,
+                    v8::String::NewFromUtf8(isolate, name.data(), v8::NewStringType::kInternalized).ToLocalChecked(),
                     a->handle());
     }
     info.GetReturnValue().Set(result);
@@ -397,6 +399,7 @@ void Group::GetAttributes(v8::Local<v8::String> property, const v8::PropertyCall
 void Group::GetSubgroups(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value> &info)
 {
     v8::Isolate *isolate = info.GetIsolate();
+    v8::Local<v8::Context> context = isolate->GetCurrentContext();
     const auto *obj = node::ObjectWrap::Unwrap<Group>(info.Holder());
 
     int ngrps = 0;
@@ -423,9 +426,8 @@ void Group::GetSubgroups(v8::Local<v8::String> property, const v8::PropertyCallb
         auto *g = new Group(grp_ids[i]);
         if (g->get_name(name.data()))
         {
-             // Suppress warning about unused return value
-             (void)result->Set(isolate->GetCurrentContext(),
-                        v8::String::NewFromUtf8(isolate, name.data(), v8::NewStringType::kNormal).ToLocalChecked(),
+             (void)result->CreateDataProperty(context,
+                        v8::String::NewFromUtf8(isolate, name.data(), v8::NewStringType::kInternalized).ToLocalChecked(),
                         g->handle());
         }
         else
@@ -480,4 +482,117 @@ void Group::Inspect(const v8::FunctionCallbackInfo<v8::Value> &args)
     args.GetReturnValue().Set(
         v8::String::NewFromUtf8(isolate, "[object Group]", v8::NewStringType::kNormal).ToLocalChecked());
 }
+
+void Group::ToJSON(const v8::FunctionCallbackInfo<v8::Value> &args)
+{
+    v8::Isolate *isolate = args.GetIsolate();
+    v8::Local<v8::Context> context = isolate->GetCurrentContext();
+    const auto *obj = node::ObjectWrap::Unwrap<Group>(args.Holder());
+    
+    // Use internalized strings for better performance
+    v8::Local<v8::String> id_str = v8::String::NewFromUtf8Literal(isolate, "id");
+    v8::Local<v8::String> name_str = v8::String::NewFromUtf8Literal(isolate, "name");
+    v8::Local<v8::String> fullname_str = v8::String::NewFromUtf8Literal(isolate, "fullname");
+    v8::Local<v8::String> dimensions_str = v8::String::NewFromUtf8Literal(isolate, "dimensions");
+    v8::Local<v8::String> variables_str = v8::String::NewFromUtf8Literal(isolate, "variables");
+    v8::Local<v8::String> attributes_str = v8::String::NewFromUtf8Literal(isolate, "attributes");
+    v8::Local<v8::String> subgroups_str = v8::String::NewFromUtf8Literal(isolate, "subgroups");
+    
+    v8::Local<v8::Object> json = v8::Object::New(isolate);
+    
+    // Add id
+    (void)json->CreateDataProperty(context, id_str, v8::Integer::New(isolate, obj->id));
+    
+    // Add name
+    std::array<char, NC_MAX_NAME + 1> name{};
+    if (obj->get_name(name.data()))
+    {
+        (void)json->CreateDataProperty(context, name_str,
+                  v8::String::NewFromUtf8(isolate, name.data(), v8::NewStringType::kInternalized).ToLocalChecked());
+    }
+    
+    // Add fullname
+    size_t len = 0;
+    int retval = nc_inq_grpname_len(obj->id, &len);
+    if (retval == NC_NOERR)
+    {
+        std::vector<char> fullname(len + 1, '\0');
+        retval = nc_inq_grpname_full(obj->id, nullptr, fullname.data());
+        if (retval == NC_NOERR)
+        {
+            (void)json->CreateDataProperty(context, fullname_str,
+                      v8::String::NewFromUtf8(isolate, fullname.data(), v8::NewStringType::kInternalized).ToLocalChecked());
+        }
+    }
+    
+    // Convert dimensions object to array
+    v8::Local<v8::Value> dimensions = args.Holder()->Get(context, dimensions_str).ToLocalChecked();
+    if (dimensions->IsObject() && !dimensions->IsNull())
+    {
+        v8::Local<v8::Object> dimsObj = dimensions->ToObject(context).ToLocalChecked();
+        v8::Local<v8::Array> propNames = dimsObj->GetOwnPropertyNames(context).ToLocalChecked();
+        v8::Local<v8::Array> dimsArray = v8::Array::New(isolate, propNames->Length());
+        
+        for (uint32_t i = 0; i < propNames->Length(); i++)
+        {
+            v8::Local<v8::Value> key = propNames->Get(context, i).ToLocalChecked();
+            v8::Local<v8::Value> value = dimsObj->Get(context, key).ToLocalChecked();
+            (void)dimsArray->Set(context, i, value);
+        }
+        (void)json->CreateDataProperty(context, dimensions_str, dimsArray);
+    }
+    
+    // Convert variables object to array
+    v8::Local<v8::Value> variables = args.Holder()->Get(context, variables_str).ToLocalChecked();
+    if (variables->IsObject() && !variables->IsNull())
+    {
+        v8::Local<v8::Object> varsObj = variables->ToObject(context).ToLocalChecked();
+        v8::Local<v8::Array> propNames = varsObj->GetOwnPropertyNames(context).ToLocalChecked();
+        v8::Local<v8::Array> varsArray = v8::Array::New(isolate, propNames->Length());
+        
+        for (uint32_t i = 0; i < propNames->Length(); i++)
+        {
+            v8::Local<v8::Value> key = propNames->Get(context, i).ToLocalChecked();
+            v8::Local<v8::Value> value = varsObj->Get(context, key).ToLocalChecked();
+            (void)varsArray->Set(context, i, value);
+        }
+        (void)json->CreateDataProperty(context, variables_str, varsArray);
+    }
+    
+    // Convert attributes object to array
+    v8::Local<v8::Value> attributes = args.Holder()->Get(context, attributes_str).ToLocalChecked();
+    if (attributes->IsObject() && !attributes->IsNull())
+    {
+        v8::Local<v8::Object> attrsObj = attributes->ToObject(context).ToLocalChecked();
+        v8::Local<v8::Array> propNames = attrsObj->GetOwnPropertyNames(context).ToLocalChecked();
+        v8::Local<v8::Array> attrsArray = v8::Array::New(isolate, propNames->Length());
+        
+        for (uint32_t i = 0; i < propNames->Length(); i++)
+        {
+            v8::Local<v8::Value> key = propNames->Get(context, i).ToLocalChecked();
+            v8::Local<v8::Value> value = attrsObj->Get(context, key).ToLocalChecked();
+            (void)attrsArray->Set(context, i, value);
+        }
+        (void)json->CreateDataProperty(context, attributes_str, attrsArray);
+    }
+    
+    // Convert subgroups object to array
+    v8::Local<v8::Value> subgroups = args.Holder()->Get(context, subgroups_str).ToLocalChecked();
+    if (subgroups->IsObject() && !subgroups->IsNull())
+    {
+        v8::Local<v8::Object> subgrpsObj = subgroups->ToObject(context).ToLocalChecked();
+        v8::Local<v8::Array> propNames = subgrpsObj->GetOwnPropertyNames(context).ToLocalChecked();
+        v8::Local<v8::Array> subgrpsArray = v8::Array::New(isolate, propNames->Length());
+        
+        for (uint32_t i = 0; i < propNames->Length(); i++)
+        {
+            v8::Local<v8::Value> key = propNames->Get(context, i).ToLocalChecked();
+            v8::Local<v8::Value> value = subgrpsObj->Get(context, key).ToLocalChecked();
+            (void)subgrpsArray->Set(context, i, value);
+        }
+        (void)json->CreateDataProperty(context, subgroups_str, subgrpsArray);
+    }
+    
+    args.GetReturnValue().Set(json);
+}
 } // namespace nodenetcdfjs

package/src/Group.h

@@ -40,6 +40,7 @@ class Group : public node::ObjectWrap
     static void AddSubgroup(const v8::FunctionCallbackInfo<v8::Value> &args);
     static void AddVariable(const v8::FunctionCallbackInfo<v8::Value> &args);
     static void Inspect(const v8::FunctionCallbackInfo<v8::Value> &args);
+    static void ToJSON(const v8::FunctionCallbackInfo<v8::Value> &args);
 
     int id{-1};
 };

package/src/Variable.cpp

@@ -42,6 +42,7 @@ void Variable::Init(v8::Local<v8::Object> exports)
     NODE_SET_PROTOTYPE_METHOD(tpl, "writeStridedSlice", Variable::WriteStridedSlice);
     NODE_SET_PROTOTYPE_METHOD(tpl, "addAttribute", Variable::AddAttribute);
     NODE_SET_PROTOTYPE_METHOD(tpl, "inspect", Variable::Inspect);
+    NODE_SET_PROTOTYPE_METHOD(tpl, "toJSON", Variable::ToJSON);
     tpl->InstanceTemplate()->SetAccessor(
         v8::String::NewFromUtf8(isolate, "id", v8::NewStringType::kNormal).ToLocalChecked(), Variable::GetId);
     tpl->InstanceTemplate()->SetAccessor(
@@ -678,6 +679,7 @@ void Variable::GetDimensions(v8::Local<v8::String> property, const v8::PropertyC
 void Variable::GetAttributes(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value> &info)
 {
     v8::Isolate *isolate = info.GetIsolate();
+    v8::Local<v8::Context> context = isolate->GetCurrentContext();
     Variable *obj = node::ObjectWrap::Unwrap<Variable>(info.Holder());
     int natts;
     int retval = nc_inq_varnatts(obj->parent_id, obj->id, &natts);
@@ -697,8 +699,8 @@ void Variable::GetAttributes(v8::Local<v8::String> property, const v8::PropertyC
             return;
         }
         Attribute *a = new Attribute(name, obj->id, obj->parent_id);
-        result->Set(isolate->GetCurrentContext(),
-                    v8::String::NewFromUtf8(isolate, name, v8::NewStringType::kNormal).ToLocalChecked(), a->handle());
+        (void)result->CreateDataProperty(context,
+                    v8::String::NewFromUtf8(isolate, name, v8::NewStringType::kInternalized).ToLocalChecked(), a->handle());
     }
     info.GetReturnValue().Set(result);
 }
@@ -1349,4 +1351,62 @@ void Variable::Inspect(const v8::FunctionCallbackInfo<v8::Value> &args)
     args.GetReturnValue().Set(
         v8::String::NewFromUtf8(isolate, "[object Variable]", v8::NewStringType::kNormal).ToLocalChecked());
 }
+
+void Variable::ToJSON(const v8::FunctionCallbackInfo<v8::Value> &args)
+{
+    v8::Isolate *isolate = args.GetIsolate();
+    v8::Local<v8::Context> context = isolate->GetCurrentContext();
+    const auto *obj = node::ObjectWrap::Unwrap<Variable>(args.Holder());
+    
+    // Use internalized strings for better performance
+    v8::Local<v8::String> id_str = v8::String::NewFromUtf8Literal(isolate, "id");
+    v8::Local<v8::String> name_str = v8::String::NewFromUtf8Literal(isolate, "name");
+    v8::Local<v8::String> type_str = v8::String::NewFromUtf8Literal(isolate, "type");
+    v8::Local<v8::String> dimensions_str = v8::String::NewFromUtf8Literal(isolate, "dimensions");
+    v8::Local<v8::String> attributes_str = v8::String::NewFromUtf8Literal(isolate, "attributes");
+    
+    v8::Local<v8::Object> json = v8::Object::New(isolate);
+    
+    // Add id
+    (void)json->CreateDataProperty(context, id_str, v8::Integer::New(isolate, obj->id));
+    
+    // Add name
+    char name[NC_MAX_NAME + 1];
+    if (obj->get_name(name))
+    {
+        (void)json->CreateDataProperty(context, name_str,
+                  v8::String::NewFromUtf8(isolate, name, v8::NewStringType::kInternalized).ToLocalChecked());
+    }
+    
+    // Add type
+    const char *type_name = (obj->type < NC_BYTE || obj->type > NC_UINT) ? "unknown" : type_names[obj->type];
+    (void)json->CreateDataProperty(context, type_str,
+              v8::String::NewFromUtf8(isolate, type_name, v8::NewStringType::kInternalized).ToLocalChecked());
+    
+    // Dimensions are already an array, just add them
+    v8::Local<v8::Value> dimensions = args.Holder()->Get(context, dimensions_str).ToLocalChecked();
+    if (dimensions->IsArray())
+    {
+        (void)json->CreateDataProperty(context, dimensions_str, dimensions);
+    }
+    
+    // Convert attributes object to array
+    v8::Local<v8::Value> attributes = args.Holder()->Get(context, attributes_str).ToLocalChecked();
+    if (attributes->IsObject() && !attributes->IsNull())
+    {
+        v8::Local<v8::Object> attrsObj = attributes->ToObject(context).ToLocalChecked();
+        v8::Local<v8::Array> propNames = attrsObj->GetOwnPropertyNames(context).ToLocalChecked();
+        v8::Local<v8::Array> attrsArray = v8::Array::New(isolate, propNames->Length());
+        
+        for (uint32_t i = 0; i < propNames->Length(); i++)
+        {
+            v8::Local<v8::Value> key = propNames->Get(context, i).ToLocalChecked();
+            v8::Local<v8::Value> value = attrsObj->Get(context, key).ToLocalChecked();
+            (void)attrsArray->Set(context, i, value);
+        }
+        (void)json->CreateDataProperty(context, attributes_str, attrsArray);
+    }
+    
+    args.GetReturnValue().Set(json);
+}
 } // namespace nodenetcdfjs

package/src/Variable.h

@@ -68,6 +68,7 @@ class Variable : public node::ObjectWrap
     static void SetCompressionLevel(v8::Local<v8::String> property, v8::Local<v8::Value> val,
                                     const v8::PropertyCallbackInfo<void> &info);
     static void Inspect(const v8::FunctionCallbackInfo<v8::Value> &args);
+    static void ToJSON(const v8::FunctionCallbackInfo<v8::Value> &args);
 
     static v8::Persistent<v8::Function> constructor;
 

package/test/attribute.js

@@ -33,4 +33,66 @@ describe('Attribute', function() {
             expect(attributes["name"].value).to.equal("air_pressure");
         });
     });
+
+    describe('toJSON', function() {
+        it('should serialize attribute without crashing', function() {
+            var file = new nodenetcdf.File("test/test_hgroups.nc", "r");
+            var attributes = file.root.subgroups["mozaic_flight_2012030419144751_ascent"].attributes;
+            var attr = attributes["airport_dep"];
+            
+            // Explicitly call toJSON to test the V8 ToLocalChecked fix
+            var json = attr.toJSON();
+            
+            expect(json).to.be.an('object');
+            expect(json).to.have.property('name', 'airport_dep');
+            expect(json).to.have.property('value', 'FRA');
+        });
+
+        it('should handle variable attribute toJSON without crashing', function() {
+            var file = new nodenetcdf.File("test/test_hgroups.nc", "r");
+            var attributes = file.root.subgroups["mozaic_flight_2012030419144751_ascent"].variables["air_press"].attributes;
+            var attr = attributes["name"];
+            
+            // Explicitly call toJSON to test the V8 ToLocalChecked fix
+            var json = attr.toJSON();
+            
+            expect(json).to.be.an('object');
+            expect(json).to.have.property('name', 'name');
+            expect(json).to.have.property('value', 'air_pressure');
+        });
+
+        it('should work with JSON.stringify', function() {
+            var file = new nodenetcdf.File("test/test_hgroups.nc", "r");
+            var attributes = file.root.subgroups["mozaic_flight_2012030419144751_ascent"].attributes;
+            var attr = attributes["airport_dep"];
+            
+            // Test that JSON.stringify (which calls toJSON internally) works
+            var jsonString = JSON.stringify(attr);
+            var json = JSON.parse(jsonString);
+            
+            expect(json).to.be.an('object');
+            expect(json).to.have.property('name', 'airport_dep');
+            expect(json).to.have.property('value', 'FRA');
+        });
+
+        it('should handle errors gracefully and return null value on type conversion errors', function() {
+            var file = new nodenetcdf.File("test/test_hgroups.nc", "r");
+            var attributes = file.root.subgroups["mozaic_flight_2012030419144751_ascent"].attributes;
+            
+            // Iterate through all attributes to find any that might have type issues
+            // The toJSON method should handle these gracefully
+            for (var attrName in attributes) {
+                var attr = attributes[attrName];
+                
+                // This should not crash even if there are type conversion errors
+                var json = attr.toJSON();
+                
+                expect(json).to.be.an('object');
+                expect(json).to.have.property('name');
+                expect(json).to.have.property('value');
+                // Value should either be a valid value or null if there was an error
+                expect(json.value === null || typeof json.value !== 'undefined').to.be.true;
+            }
+        });
+    });
 });

package/test/json.js

@@ -0,0 +1,174 @@
+var expect = require("chai").expect,
+    nodenetcdf = require("../build/Release/nodenetcdf.node");
+
+describe('JSON Serialization', function() {
+    var file;
+    
+    beforeEach(function() {
+        file = new nodenetcdf.File("test/testrh.nc", "r");
+    });
+    
+    afterEach(function() {
+        file.close();
+    });
+    
+    describe('Dimension', function() {
+        it('should serialize dimension to JSON', function() {
+            var dim = file.root.dimensions['dim1'];
+            var json = JSON.parse(JSON.stringify(dim));
+            
+            expect(json).to.be.an('object');
+            expect(json).to.have.property('id');
+            expect(json).to.have.property('name', 'dim1');
+            expect(json).to.have.property('length', 10000);
+        });
+        
+        it('should have all required properties in JSON', function() {
+            var dim = file.root.dimensions['dim1'];
+            var json = JSON.parse(JSON.stringify(dim));
+            
+            expect(json.id).to.be.a('number');
+            expect(json.name).to.be.a('string');
+            expect(json.length).to.be.a('number');
+        });
+    });
+    
+    describe('Attribute', function() {
+        it('should serialize group attribute to JSON', function() {
+            var attributes = file.root.attributes;
+            for (var attrName in attributes) {
+                var attr = attributes[attrName];
+                var json = JSON.parse(JSON.stringify(attr));
+                
+                expect(json).to.be.an('object');
+                expect(json).to.have.property('name');
+                expect(json).to.have.property('value');
+                return; // Test first attribute
+            }
+        });
+        
+        it('should serialize variable attribute to JSON', function() {
+            var variables = file.root.variables;
+            for (var varName in variables) {
+                var variable = variables[varName];
+                var varAttrs = variable.attributes;
+                for (var attrName in varAttrs) {
+                    var attr = varAttrs[attrName];
+                    var json = JSON.parse(JSON.stringify(attr));
+                    
+                    expect(json).to.be.an('object');
+                    expect(json).to.have.property('name');
+                    expect(json).to.have.property('value');
+                    return; // Test first attribute
+                }
+            }
+        });
+        
+        it('should not serialize attribute values as null', function() {
+            // Check all attributes in file don't have null values when serialized
+            var jsonStr = JSON.stringify(file);
+            var nullMatches = jsonStr.match(/"value":\s*null/g);
+            var nullCount = nullMatches ? nullMatches.length : 0;
+            
+            expect(nullCount).to.equal(0, 'Found ' + nullCount + ' null attribute values in JSON');
+        });
+        
+        it('should convert TypedArray values to regular arrays in JSON', function() {
+            // Find an attribute with a TypedArray value
+            var variables = file.root.variables;
+            for (var varName in variables) {
+                var variable = variables[varName];
+                var varAttrs = variable.attributes;
+                for (var attrName in varAttrs) {
+                    var attr = varAttrs[attrName];
+                    
+                    // Check if value is a TypedArray
+                    if (attr.value && typeof attr.value === 'object' && 
+                        attr.value.constructor && attr.value.constructor.name.includes('Array') &&
+                        !Array.isArray(attr.value)) {
+                        
+                        // It's a TypedArray, test it converts to regular array
+                        var json = JSON.parse(JSON.stringify(attr));
+                        
+                        // In JSON, it should be a regular array
+                        expect(Array.isArray(json.value)).to.be.true;
+                        return;
+                    }
+                }
+            }
+        });
+    });
+    
+    describe('Variable', function() {
+        it('should serialize variable to JSON', function() {
+            var variable = file.root.variables['var1'];
+            var json = JSON.parse(JSON.stringify(variable));
+            
+            expect(json).to.be.an('object');
+            expect(json).to.have.property('id');
+            expect(json).to.have.property('name', 'var1');
+            expect(json).to.have.property('type', 'double');
+        });
+        
+        it('should have all required properties in JSON', function() {
+            var variable = file.root.variables['var1'];
+            var json = JSON.parse(JSON.stringify(variable));
+            
+            expect(json.id).to.be.a('number');
+            expect(json.name).to.be.a('string');
+            expect(json.type).to.be.a('string');
+        });
+    });
+    
+    describe('Group', function() {
+        it('should serialize group to JSON', function() {
+            var group = file.root;
+            var json = JSON.parse(JSON.stringify(group));
+            
+            expect(json).to.be.an('object');
+            expect(json).to.have.property('id');
+            expect(json).to.have.property('name');
+            expect(json).to.have.property('fullname');
+        });
+        
+        it('should have all required properties in JSON', function() {
+            var group = file.root;
+            var json = JSON.parse(JSON.stringify(group));
+            
+            expect(json.id).to.be.a('number');
+            expect(json.name).to.be.a('string');
+            expect(json.fullname).to.be.a('string');
+        });
+        
+        it('should recursively serialize all children', function() {
+            var group = file.root;
+            var json = JSON.parse(JSON.stringify(group));
+            
+            expect(json).to.have.property('dimensions');
+            expect(json).to.have.property('variables');
+            expect(json).to.have.property('attributes');
+            expect(json).to.have.property('subgroups');
+        });
+    });
+    
+    describe('File', function() {
+        it('should serialize file to JSON', function() {
+            var json = JSON.parse(JSON.stringify(file));
+            
+            expect(json).to.be.an('object');
+            expect(json).to.have.property('id');
+            expect(json).to.have.property('name');
+            expect(json).to.have.property('fullname');
+        });
+        
+        it('should recursively serialize entire file structure', function() {
+            var json = JSON.parse(JSON.stringify(file));
+            
+            // File should serialize as root group with all children
+            expect(json).to.have.property('dimensions');
+            expect(json).to.have.property('variables');
+            expect(json.variables).to.be.an('object');
+            expect(json.dimensions).to.be.an('object');
+        });
+    });
+});