nodenetcdf 4.9.32 → 4.9.34

package/src/Variable.cpp

@@ -22,9 +22,7 @@ Variable::Variable(int id_, int parent_id_) noexcept
     Wrap(obj);
     const int retval = nc_inq_var(parent_id, id, nullptr, &type, &ndims, nullptr, nullptr);
     if (retval != NC_NOERR)
-    {
         throw_netcdf_error(isolate, retval);
-    }
 }
 
 void Variable::Init(v8::Local<v8::Object> exports)
@@ -104,8 +102,14 @@ void Variable::Write(const v8::FunctionCallbackInfo<v8::Value> &args)
 
     if (args.Length() != obj->ndims + 1)
     {
+        char name[NC_MAX_NAME + 1];
+        obj->get_name(name);
+        char error_msg[512];
+        snprintf(error_msg, sizeof(error_msg), 
+                "Variable.write() for '%s': Wrong number of arguments. Expected %d (position arguments) + 1 (value) = %d, but got %d",
+                name, obj->ndims, obj->ndims + 1, args.Length());
         isolate->ThrowException(v8::Exception::TypeError(
-            v8::String::NewFromUtf8(isolate, "Wrong number of arguments", v8::NewStringType::kNormal)
+            v8::String::NewFromUtf8(isolate, error_msg, v8::NewStringType::kNormal)
                 .ToLocalChecked()));
         return;
     }
@@ -162,33 +166,48 @@ void Variable::Write(const v8::FunctionCallbackInfo<v8::Value> &args)
     }
     break;
     default:
+        char name[NC_MAX_NAME + 1];
+        obj->get_name(name);
+        char error_msg[256];
+        snprintf(error_msg, sizeof(error_msg),
+                "Variable.write() for '%s': Variable type %d not supported for write operations",
+                name, obj->type);
         isolate->ThrowException(v8::Exception::TypeError(
-            v8::String::NewFromUtf8(isolate, "Variable type not supported yet", v8::NewStringType::kNormal)
+            v8::String::NewFromUtf8(isolate, error_msg, v8::NewStringType::kNormal)
                 .ToLocalChecked()));
         return;
     }
 
     if (retval != NC_NOERR)
-    {
         throw_netcdf_error(isolate, retval);
-    }
 }
 
 void Variable::WriteSlice(const v8::FunctionCallbackInfo<v8::Value> &args)
 {
     v8::Isolate *isolate = args.GetIsolate();
     Variable *obj = node::ObjectWrap::Unwrap<Variable>(args.Holder());
+    char name[NC_MAX_NAME + 1];
+    obj->get_name(name);
+    
     if (args.Length() != 2 * obj->ndims + 1)
     {
+        char error_msg[512];
+        snprintf(error_msg, sizeof(error_msg),
+                "Variable.writeSlice() for '%s': Wrong number of arguments. Expected %d pairs (pos,size) + 1 (array) = %d, but got %d",
+                name, obj->ndims, 2 * obj->ndims + 1, args.Length());
         isolate->ThrowException(v8::Exception::TypeError(
-            v8::String::NewFromUtf8(isolate, "Wrong number of arguments", v8::NewStringType::kNormal)
+            v8::String::NewFromUtf8(isolate, error_msg, v8::NewStringType::kNormal)
                 .ToLocalChecked()));
         return;
     }
     if (!args[2 * obj->ndims]->IsTypedArray())
     {
+        char error_msg[256];
+        snprintf(error_msg, sizeof(error_msg),
+                "Variable.writeSlice() for '%s': Last argument must be a typed array (Int8Array, Float32Array, etc.), but got %s",
+                name, *v8::String::Utf8Value(isolate, args[2 * obj->ndims]->TypeOf(isolate)));
         isolate->ThrowException(v8::Exception::TypeError(
-            v8::String::NewFromUtf8(isolate, "Expecting a typed array", v8::NewStringType::kNormal).ToLocalChecked()));
+            v8::String::NewFromUtf8(isolate, error_msg, v8::NewStringType::kNormal).ToLocalChecked()));
         return;
     }
     size_t *pos = new size_t[obj->ndims];
@@ -204,44 +223,61 @@ void Variable::WriteSlice(const v8::FunctionCallbackInfo<v8::Value> &args)
     v8::Local<v8::TypedArray> val = v8::Local<v8::TypedArray>::Cast(args[2 * obj->ndims]);
     if (val->Length() != total_size)
     {
+        char error_msg[512];
+        snprintf(error_msg, sizeof(error_msg),
+                "Variable.writeSlice() for '%s': Array size mismatch. Expected %zu elements (product of sizes), but got %zu",
+                name, total_size, val->Length());
         isolate->ThrowException(v8::Exception::TypeError(
-            v8::String::NewFromUtf8(isolate, "Wrong size of array", v8::NewStringType::kNormal).ToLocalChecked()));
+            v8::String::NewFromUtf8(isolate, error_msg, v8::NewStringType::kNormal).ToLocalChecked()));
         delete[] pos;
         delete[] size;
         return;
     }
 
     bool correct_type;
+    const char *expected_type_name = nullptr;
     switch (obj->type)
     {
     case NC_BYTE:
     case NC_CHAR:
         correct_type = val->IsInt8Array();
+        expected_type_name = "Int8Array";
         break;
     case NC_SHORT:
         correct_type = val->IsInt16Array();
+        expected_type_name = "Int16Array";
         break;
     case NC_INT:
         correct_type = val->IsInt32Array();
+        expected_type_name = "Int32Array";
         break;
     case NC_FLOAT:
         correct_type = val->IsFloat32Array();
+        expected_type_name = "Float32Array";
         break;
     case NC_DOUBLE:
         correct_type = val->IsFloat64Array();
+        expected_type_name = "Float64Array";
         break;
     case NC_UBYTE:
         correct_type = val->IsUint8Array();
+        expected_type_name = "Uint8Array";
         break;
     case NC_USHORT:
         correct_type = val->IsUint16Array();
+        expected_type_name = "Uint16Array";
         break;
     case NC_UINT:
         correct_type = val->IsUint32Array();
+        expected_type_name = "Uint32Array";
         break;
     default:
+        char error_msg[256];
+        snprintf(error_msg, sizeof(error_msg),
+                "Variable.writeSlice() for '%s': Variable type %d (%s) not supported for write operations",
+                name, obj->type, type_names[obj->type]);
         isolate->ThrowException(v8::Exception::TypeError(
-            v8::String::NewFromUtf8(isolate, "Variable type not supported yet", v8::NewStringType::kNormal)
+            v8::String::NewFromUtf8(isolate, error_msg, v8::NewStringType::kNormal)
                 .ToLocalChecked()));
         delete[] pos;
         delete[] size;
@@ -249,8 +285,13 @@ void Variable::WriteSlice(const v8::FunctionCallbackInfo<v8::Value> &args)
     }
     if (!correct_type)
     {
+        v8::String::Utf8Value actual_type(isolate, val->GetConstructorName());
+        char error_msg[512];
+        snprintf(error_msg, sizeof(error_msg),
+                "Variable.writeSlice() for '%s': Array type mismatch. Variable type is %s, expected %s array, but got %s",
+                name, type_names[obj->type], expected_type_name, *actual_type);
         isolate->ThrowException(v8::Exception::TypeError(
-            v8::String::NewFromUtf8(isolate, "Wrong array type", v8::NewStringType::kNormal).ToLocalChecked()));
+            v8::String::NewFromUtf8(isolate, error_msg, v8::NewStringType::kNormal).ToLocalChecked()));
         delete[] pos;
         delete[] size;
         return;
@@ -268,17 +309,28 @@ void Variable::WriteStridedSlice(const v8::FunctionCallbackInfo<v8::Value> &args
 {
     v8::Isolate *isolate = args.GetIsolate();
     Variable *obj = node::ObjectWrap::Unwrap<Variable>(args.Holder());
+    char name[NC_MAX_NAME + 1];
+    obj->get_name(name);
+    
     if (args.Length() != 3 * obj->ndims + 1)
     {
+        char error_msg[512];
+        snprintf(error_msg, sizeof(error_msg),
+                "Variable.writeStridedSlice() for '%s': Wrong number of arguments. Expected %d triplets (pos,size,stride) + 1 (array) = %d, but got %d",
+                name, obj->ndims, 3 * obj->ndims + 1, args.Length());
         isolate->ThrowException(v8::Exception::TypeError(
-            v8::String::NewFromUtf8(isolate, "Wrong number of arguments", v8::NewStringType::kNormal)
+            v8::String::NewFromUtf8(isolate, error_msg, v8::NewStringType::kNormal)
                 .ToLocalChecked()));
         return;
     }
     if (!args[3 * obj->ndims]->IsTypedArray())
     {
+        char error_msg[256];
+        snprintf(error_msg, sizeof(error_msg),
+                "Variable.writeStridedSlice() for '%s': Last argument must be a typed array, but got %s",
+                name, *v8::String::Utf8Value(isolate, args[3 * obj->ndims]->TypeOf(isolate)));
         isolate->ThrowException(v8::Exception::TypeError(
-            v8::String::NewFromUtf8(isolate, "Expecting a typed array", v8::NewStringType::kNormal).ToLocalChecked()));
+            v8::String::NewFromUtf8(isolate, error_msg, v8::NewStringType::kNormal).ToLocalChecked()));
         return;
     }
     size_t *pos = new size_t[obj->ndims];
@@ -296,8 +348,12 @@ void Variable::WriteStridedSlice(const v8::FunctionCallbackInfo<v8::Value> &args
     v8::Local<v8::TypedArray> val = v8::Local<v8::TypedArray>::Cast(args[3 * obj->ndims]);
     if (val->Length() != total_size)
     {
+        char error_msg[512];
+        snprintf(error_msg, sizeof(error_msg),
+                "Variable.writeStridedSlice() for '%s': Array size mismatch. Expected %zu elements (product of sizes), but got %zu",
+                name, total_size, val->Length());
         isolate->ThrowException(v8::Exception::TypeError(
-            v8::String::NewFromUtf8(isolate, "Wrong size of array", v8::NewStringType::kNormal).ToLocalChecked()));
+            v8::String::NewFromUtf8(isolate, error_msg, v8::NewStringType::kNormal).ToLocalChecked()));
         delete[] pos;
         delete[] size;
         delete[] stride;
@@ -305,36 +361,49 @@ void Variable::WriteStridedSlice(const v8::FunctionCallbackInfo<v8::Value> &args
     }
 
     bool correct_type;
+    const char *expected_type_name = nullptr;
     switch (obj->type)
     {
     case NC_BYTE:
     case NC_CHAR:
         correct_type = val->IsInt8Array();
+        expected_type_name = "Int8Array";
         break;
     case NC_SHORT:
         correct_type = val->IsInt16Array();
+        expected_type_name = "Int16Array";
         break;
     case NC_INT:
         correct_type = val->IsInt32Array();
+        expected_type_name = "Int32Array";
         break;
     case NC_FLOAT:
         correct_type = val->IsFloat32Array();
+        expected_type_name = "Float32Array";
         break;
     case NC_DOUBLE:
         correct_type = val->IsFloat64Array();
+        expected_type_name = "Float64Array";
         break;
     case NC_UBYTE:
         correct_type = val->IsUint8Array();
+        expected_type_name = "Uint8Array";
         break;
     case NC_USHORT:
         correct_type = val->IsUint16Array();
+        expected_type_name = "Uint16Array";
         break;
     case NC_UINT:
         correct_type = val->IsUint32Array();
+        expected_type_name = "Uint32Array";
         break;
     default:
+        char error_msg[256];
+        snprintf(error_msg, sizeof(error_msg),
+                "Variable.writeStridedSlice() for '%s': Variable type %d (%s) not supported for write operations",
+                name, obj->type, type_names[obj->type]);
         isolate->ThrowException(v8::Exception::TypeError(
-            v8::String::NewFromUtf8(isolate, "Variable type not supported yet", v8::NewStringType::kNormal)
+            v8::String::NewFromUtf8(isolate, error_msg, v8::NewStringType::kNormal)
                 .ToLocalChecked()));
         delete[] pos;
         delete[] size;
@@ -343,8 +412,13 @@ void Variable::WriteStridedSlice(const v8::FunctionCallbackInfo<v8::Value> &args
     }
     if (!correct_type)
     {
+        v8::String::Utf8Value actual_type(isolate, val->GetConstructorName());
+        char error_msg[512];
+        snprintf(error_msg, sizeof(error_msg),
+                "Variable.writeStridedSlice() for '%s': Array type mismatch. Variable type is %s, expected %s array, but got %s",
+                name, type_names[obj->type], expected_type_name, *actual_type);
         isolate->ThrowException(v8::Exception::TypeError(
-            v8::String::NewFromUtf8(isolate, "Wrong array type", v8::NewStringType::kNormal).ToLocalChecked()));
+            v8::String::NewFromUtf8(isolate, error_msg, v8::NewStringType::kNormal).ToLocalChecked()));
         delete[] pos;
         delete[] size;
         delete[] stride;
@@ -352,9 +426,7 @@ void Variable::WriteStridedSlice(const v8::FunctionCallbackInfo<v8::Value> &args
     }
     int retval = nc_put_vars(obj->parent_id, obj->id, pos, size, stride, val->Buffer()->GetBackingStore()->Data());
     if (retval != NC_NOERR)
-    {
         throw_netcdf_error(isolate, retval);
-    }
     delete[] pos;
     delete[] size;
     delete[] stride;
@@ -364,17 +436,28 @@ void Variable::Read(const v8::FunctionCallbackInfo<v8::Value> &args)
 {
     v8::Isolate *isolate = args.GetIsolate();
     Variable *obj = node::ObjectWrap::Unwrap<Variable>(args.Holder());
+    char name[NC_MAX_NAME + 1];
+    obj->get_name(name);
+    
     if (args.Length() != obj->ndims)
     {
+        char error_msg[512];
+        snprintf(error_msg, sizeof(error_msg),
+                "Variable.read() for '%s': Wrong number of arguments. Expected %d position indices (one per dimension), but got %d",
+                name, obj->ndims, args.Length());
         isolate->ThrowException(v8::Exception::TypeError(
-            v8::String::NewFromUtf8(isolate, "Wrong number of arguments", v8::NewStringType::kNormal)
+            v8::String::NewFromUtf8(isolate, error_msg, v8::NewStringType::kNormal)
                 .ToLocalChecked()));
         return;
     }
     if (obj->type < NC_BYTE || obj->type > NC_UINT)
     {
+        char error_msg[256];
+        snprintf(error_msg, sizeof(error_msg),
+                "Variable.read() for '%s': Variable type %d not supported for read operations",
+                name, obj->type);
         isolate->ThrowException(v8::Exception::TypeError(
-            v8::String::NewFromUtf8(isolate, "Variable type not supported yet", v8::NewStringType::kNormal)
+            v8::String::NewFromUtf8(isolate, error_msg, v8::NewStringType::kNormal)
                 .ToLocalChecked()));
         return;
     }
@@ -446,13 +529,9 @@ void Variable::Read(const v8::FunctionCallbackInfo<v8::Value> &args)
     break;
     }
     if (retval != NC_NOERR)
-    {
         throw_netcdf_error(isolate, retval);
-    }
     else
-    {
         args.GetReturnValue().Set(result);
-    }
     delete[] pos;
     delete[] size;
 }
@@ -461,17 +540,28 @@ void Variable::ReadSlice(const v8::FunctionCallbackInfo<v8::Value> &args)
 {
     v8::Isolate *isolate = args.GetIsolate();
     Variable *obj = node::ObjectWrap::Unwrap<Variable>(args.Holder());
+    char name[NC_MAX_NAME + 1];
+    obj->get_name(name);
+    
     if (args.Length() != 2 * obj->ndims)
     {
+        char error_msg[512];
+        snprintf(error_msg, sizeof(error_msg),
+                "Variable.readSlice() for '%s': Wrong number of arguments. Expected %d pairs (pos,size) = %d arguments, but got %d",
+                name, obj->ndims, 2 * obj->ndims, args.Length());
         isolate->ThrowException(v8::Exception::TypeError(
-            v8::String::NewFromUtf8(isolate, "Wrong number of arguments", v8::NewStringType::kNormal)
+            v8::String::NewFromUtf8(isolate, error_msg, v8::NewStringType::kNormal)
                 .ToLocalChecked()));
         return;
     }
     if (obj->type < NC_BYTE || obj->type > NC_UINT)
     {
+        char error_msg[256];
+        snprintf(error_msg, sizeof(error_msg),
+                "Variable.readSlice() for '%s': Variable type %d not supported for read operations",
+                name, obj->type);
         isolate->ThrowException(v8::Exception::TypeError(
-            v8::String::NewFromUtf8(isolate, "Variable type not supported yet", v8::NewStringType::kNormal)
+            v8::String::NewFromUtf8(isolate, error_msg, v8::NewStringType::kNormal)
                 .ToLocalChecked()));
         return;
     }
@@ -525,8 +615,12 @@ void Variable::ReadSlice(const v8::FunctionCallbackInfo<v8::Value> &args)
         result = v8::Uint32Array::New(buffer, 0, total_size);
         break;
     default:
+        char error_msg[256];
+        snprintf(error_msg, sizeof(error_msg),
+                "Variable.readSlice() for '%s': Variable type %d (%s) not supported for creating typed array result",
+                name, obj->type, type_names[obj->type]);
         isolate->ThrowException(v8::Exception::TypeError(
-            v8::String::NewFromUtf8(isolate, "Variable type not supported yet", v8::NewStringType::kNormal)
+            v8::String::NewFromUtf8(isolate, error_msg, v8::NewStringType::kNormal)
                 .ToLocalChecked()));
         delete[] pos;
         delete[] size;
@@ -541,17 +635,28 @@ void Variable::ReadStridedSlice(const v8::FunctionCallbackInfo<v8::Value> &args)
 {
     v8::Isolate *isolate = args.GetIsolate();
     Variable *obj = node::ObjectWrap::Unwrap<Variable>(args.Holder());
+    char name[NC_MAX_NAME + 1];
+    obj->get_name(name);
+    
     if (args.Length() != 3 * obj->ndims)
     {
+        char error_msg[512];
+        snprintf(error_msg, sizeof(error_msg),
+                "Variable.readStridedSlice() for '%s': Wrong number of arguments. Expected %d triplets (pos,size,stride) = %d arguments, but got %d",
+                name, obj->ndims, 3 * obj->ndims, args.Length());
         isolate->ThrowException(v8::Exception::TypeError(
-            v8::String::NewFromUtf8(isolate, "Wrong number of arguments", v8::NewStringType::kNormal)
+            v8::String::NewFromUtf8(isolate, error_msg, v8::NewStringType::kNormal)
                 .ToLocalChecked()));
         return;
     }
     if (obj->type < NC_BYTE || obj->type > NC_UINT)
     {
+        char error_msg[256];
+        snprintf(error_msg, sizeof(error_msg),
+                "Variable.readStridedSlice() for '%s': Variable type %d not supported for read operations",
+                name, obj->type);
         isolate->ThrowException(v8::Exception::TypeError(
-            v8::String::NewFromUtf8(isolate, "Variable type not supported yet", v8::NewStringType::kNormal)
+            v8::String::NewFromUtf8(isolate, error_msg, v8::NewStringType::kNormal)
                 .ToLocalChecked()));
         return;
     }
@@ -618,10 +723,17 @@ void Variable::AddAttribute(const v8::FunctionCallbackInfo<v8::Value> &args)
 {
     v8::Isolate *isolate = args.GetIsolate();
     Variable *obj = node::ObjectWrap::Unwrap<Variable>(args.Holder());
+    char var_name[NC_MAX_NAME + 1];
+    obj->get_name(var_name);
+    
     if (args.Length() < 3)
     {
+        char error_msg[512];
+        snprintf(error_msg, sizeof(error_msg),
+                "Variable.addAttribute() for '%s': Wrong number of arguments. Expected 3 (name, type, value), but got %d",
+                var_name, args.Length());
         isolate->ThrowException(v8::Exception::TypeError(
-            v8::String::NewFromUtf8(isolate, "Wrong number of arguments", v8::NewStringType::kNormal)
+            v8::String::NewFromUtf8(isolate, error_msg, v8::NewStringType::kNormal)
                 .ToLocalChecked()));
         return;
     }
@@ -633,8 +745,17 @@ void Variable::AddAttribute(const v8::FunctionCallbackInfo<v8::Value> &args)
     int type = get_type(type_str);
     if (type == NC2_ERR)
     {
+        std::string attr_name = *v8::String::Utf8Value(
+#if NODE_MAJOR_VERSION >= 8
+            isolate,
+#endif
+            args[0]);
+        char error_msg[512];
+        snprintf(error_msg, sizeof(error_msg),
+                "Variable.addAttribute() for '%s': Unknown attribute type '%s' for attribute '%s'. Valid types are: byte, char, short, int, float, double, ubyte, ushort, uint",
+                var_name, type_str.c_str(), attr_name.c_str());
         isolate->ThrowException(v8::Exception::TypeError(
-            v8::String::NewFromUtf8(isolate, "Unknown variable type", v8::NewStringType::kNormal).ToLocalChecked()));
+            v8::String::NewFromUtf8(isolate, error_msg, v8::NewStringType::kNormal).ToLocalChecked()));
         return;
     }
     Attribute *res = new Attribute(*v8::String::Utf8Value(
@@ -727,9 +848,7 @@ void Variable::GetName(v8::Local<v8::String> property, const v8::PropertyCallbac
     Variable *obj = node::ObjectWrap::Unwrap<Variable>(info.Holder());
     char name[NC_MAX_NAME + 1];
     if (obj->get_name(name))
-    {
         info.GetReturnValue().Set(v8::String::NewFromUtf8(isolate, name, v8::NewStringType::kNormal).ToLocalChecked());
-    }
 }
 
 void Variable::SetName(v8::Local<v8::String> property, v8::Local<v8::Value> val,
@@ -792,17 +911,11 @@ void Variable::SetEndianness(v8::Local<v8::String> property, v8::Local<v8::Value
         val->ToString(isolate->GetCurrentContext()).ToLocalChecked());
     int v;
     if (arg == "little")
-    {
         v = NC_ENDIAN_LITTLE;
-    }
     else if (arg == "big")
-    {
         v = NC_ENDIAN_BIG;
-    }
     else if (arg == "native")
-    {
         v = NC_ENDIAN_NATIVE;
-    }
     else
     {
         isolate->ThrowException(v8::Exception::TypeError(
@@ -856,13 +969,9 @@ void Variable::SetChecksumMode(v8::Local<v8::String> property, v8::Local<v8::Val
         val->ToString(isolate->GetCurrentContext()).ToLocalChecked());
     int v;
     if (arg == "none")
-    {
         v = NC_NOCHECKSUM;
-    }
     else if (arg == "fletcher32")
-    {
         v = NC_FLETCHER32;
-    }
     else
     {
         isolate->ThrowException(v8::Exception::TypeError(
@@ -916,13 +1025,9 @@ void Variable::SetChunkMode(v8::Local<v8::String> property, v8::Local<v8::Value>
         val->ToString(isolate->GetCurrentContext()).ToLocalChecked());
     int v;
     if (arg == "contiguous")
-    {
         v = NC_CONTIGUOUS;
-    }
     else if (arg == "chunked")
-    {
         v = NC_CHUNKED;
-    }
     else
     {
         isolate->ThrowException(v8::Exception::TypeError(
@@ -946,9 +1051,7 @@ void Variable::SetChunkMode(v8::Local<v8::String> property, v8::Local<v8::Value>
     }
     retval = nc_def_var_chunking(obj->parent_id, obj->id, v, sizes);
     if (retval != NC_NOERR)
-    {
         throw_netcdf_error(isolate, retval);
-    }
     delete[] sizes;
 }
 
@@ -966,9 +1069,7 @@ void Variable::GetChunkSizes(v8::Local<v8::String> property, const v8::PropertyC
     }
     v8::Local<v8::Array> result = v8::Array::New(isolate);
     for (int i = 0; i < obj->ndims; i++)
-    {
         result->Set(isolate->GetCurrentContext(), i, v8::Integer::New(isolate, i));
-    }
     info.GetReturnValue().Set(result);
     delete[] sizes;
 }
@@ -1005,17 +1106,13 @@ void Variable::SetChunkSizes(v8::Local<v8::String> property, v8::Local<v8::Value
     }
     size_t *sizes = new size_t[obj->ndims];
     for (int i = 0; i < obj->ndims; i++)
-    {
         sizes[i] = array->Get(isolate->GetCurrentContext(), i)
                        .ToLocalChecked()
                        ->Uint32Value(isolate->GetCurrentContext())
                        .ToChecked();
-    }
     retval = nc_def_var_chunking(obj->parent_id, obj->id, v, sizes);
     if (retval != NC_NOERR)
-    {
         throw_netcdf_error(isolate, retval);
-    }
     delete[] sizes;
 }
 
@@ -1066,9 +1163,7 @@ void Variable::SetFillMode(v8::Local<v8::String> property, v8::Local<v8::Value>
     }
     retval = nc_def_var_fill(obj->parent_id, obj->id, v, value);
     if (retval != NC_NOERR)
-    {
         throw_netcdf_error(isolate, retval);
-    }
     delete[] value;
 }
 
@@ -1211,9 +1306,7 @@ void Variable::SetFillValue(v8::Local<v8::String> property, v8::Local<v8::Value>
         return;
     }
     if (retval != NC_NOERR)
-    {
         throw_netcdf_error(isolate, retval);
-    }
 }
 
 void Variable::GetCompressionShuffle(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value> &info)
@@ -1299,9 +1392,7 @@ void Variable::SetCompressionDeflate(v8::Local<v8::String> property, v8::Local<v
     }
     retval = nc_def_var_deflate(obj->parent_id, obj->id, v1, v, v2);
     if (retval != NC_NOERR)
-    {
         throw_netcdf_error(isolate, retval);
-    }
 }
 
 void Variable::GetCompressionLevel(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value> &info)
@@ -1358,7 +1449,6 @@ void Variable::ToJSON(const v8::FunctionCallbackInfo<v8::Value> &args)
     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");
@@ -1367,41 +1457,70 @@ void Variable::ToJSON(const v8::FunctionCallbackInfo<v8::Value> &args)
     
     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);
+        v8::Local<v8::Array> dimsArray = v8::Local<v8::Array>::Cast(dimensions);
+        v8::Local<v8::Array> newDimsArray = v8::Array::New(isolate, dimsArray->Length());
+        v8::Local<v8::String> toJSONStr = v8::String::NewFromUtf8Literal(isolate, "toJSON");
+        
+        for (uint32_t i = 0; i < dimsArray->Length(); i++)
+        {
+            v8::Local<v8::Value> value = dimsArray->Get(context, i).ToLocalChecked();
+            
+            // Call toJSON if available to ensure proper serialization
+            if (value->IsObject())
+            {
+                v8::Local<v8::Object> valueObj = value->ToObject(context).ToLocalChecked();
+                v8::Local<v8::Value> toJSON = valueObj->Get(context, toJSONStr).ToLocalChecked();
+                if (toJSON->IsFunction())
+                {
+                    v8::Local<v8::Function> toJSONFunc = v8::Local<v8::Function>::Cast(toJSON);
+                    value = toJSONFunc->Call(context, valueObj, 0, nullptr).ToLocalChecked();
+                }
+            }
+            (void)newDimsArray->Set(context, i, value);
+        }
+        (void)json->CreateDataProperty(context, dimensions_str, newDimsArray);
     }
     
-    // Convert attributes object to array
+    // Convert attributes object to array, calling toJSON on each item
     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());
+        v8::Local<v8::String> toJSONStr = v8::String::NewFromUtf8Literal(isolate, "toJSON");
         
         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();
+            
+            // Call toJSON if available to ensure proper serialization
+            if (value->IsObject())
+            {
+                v8::Local<v8::Object> valueObj = value->ToObject(context).ToLocalChecked();
+                v8::Local<v8::Value> toJSON = valueObj->Get(context, toJSONStr).ToLocalChecked();
+                if (toJSON->IsFunction())
+                {
+                    v8::Local<v8::Function> toJSONFunc = v8::Local<v8::Function>::Cast(toJSON);
+                    value = toJSONFunc->Call(context, valueObj, 0, nullptr).ToLocalChecked();
+                }
+            }
             (void)attrsArray->Set(context, i, value);
         }
         (void)json->CreateDataProperty(context, attributes_str, attrsArray);