src: added Freeze and Seal method to Object class.

doc/object.md

@@ -217,6 +217,30 @@ void Napi::Object::DefineProperties (____ properties)
 
 Defines properties on the object.
 
+### Freeze()
+
+```cpp
+void Napi::Object::Freeze()
+```
+
+The `Napi::Object::Freeze()` method freezes an object. A frozen object can no
+longer changed. Freezing an object prevents new properties from being added to
+it, existing properties from being removed, prevents changing the
+enumerability, configurability, or writability of existing properties and
+prevents the valuee of existing properties from being changed. In addition,
+freezing an object also prevents its prototype from being changed.
+
+### Seal()
+
+```cpp
+void Napi::Object::Seal()
+```
+
+The `Napi::Object::Seal()` method seals an object, preventing new properties
+from being added to it and marking all existing properties as non-configurable.
+Values of present properties can still be changed as long as thery are
+writable.
+
 ### operator\[\]()
 
 ```cpp

napi-inl.h

@@ -1378,6 +1378,18 @@ inline void Object::AddFinalizer(Finalizer finalizeCallback,
   }
 }
 
+#if NAPI_VERSION >= 8
+inline void Object::Freeze() {
+  napi_status status = napi_object_freeze(_env, _value);
+  NAPI_THROW_IF_FAILED_VOID(_env, status);
+}
+
+inline void Object::Seal() {
+  napi_status status = napi_object_seal(_env, _value);
+  NAPI_THROW_IF_FAILED_VOID(_env, status);
+}
+#endif  // NAPI_VERSION >= 8
+
 ////////////////////////////////////////////////////////////////////////////////
 // External class
 ////////////////////////////////////////////////////////////////////////////////

napi.h

@@ -752,6 +752,10 @@ namespace Napi {
     inline void AddFinalizer(Finalizer finalizeCallback,
                              T* data,
                              Hint* finalizeHint);
+#if NAPI_VERSION >= 8
+    void Freeze();
+    void Seal();
+#endif  // NAPI_VERSION >= 8
   };
 
   template <typename T>

test/binding.cc

@@ -66,6 +66,9 @@ Object InitObjectReference(Env env);
 Object InitReference(Env env);
 Object InitVersionManagement(Env env);
 Object InitThunkingManual(Env env);
+#if (NAPI_VERSION > 7)
+Object InitObjectFreezeSeal(Env env);
+#endif
 
 Object Init(Env env, Object exports) {
 #if (NAPI_VERSION > 5)
@@ -139,6 +142,9 @@ Object Init(Env env, Object exports) {
   exports.Set("reference", InitReference(env));
   exports.Set("version_management", InitVersionManagement(env));
   exports.Set("thunking_manual", InitThunkingManual(env));
+#if (NAPI_VERSION > 7)
+  exports.Set("object_freeze_seal", InitObjectFreezeSeal(env));
+#endif
   return exports;
 }
 

test/binding.gyp

@@ -34,6 +34,7 @@
         'object/has_own_property.cc',
         'object/has_property.cc',
         'object/object.cc',
+        'object/object_freeze_seal.cc',
         'object/set_property.cc',
         'object/subscript_operator.cc',
         'promise.cc',

test/index.js

@@ -112,6 +112,10 @@ if (majorNodeVersion < 12) {
   testModules.splice(testModules.indexOf('objectwrap_worker_thread'), 1);
 }
 
+if (napiVersion < 8) {
+  testModules.splice(testModules.indexOf('object/object_freeze_seal'), 1);
+}
+
 (async function() {
 console.log(`Testing with N-API Version '${napiVersion}'.`);
 

test/object/object_freeze_seal.cc

@@ -0,0 +1,24 @@
+#include "napi.h"
+
+#if (NAPI_VERSION > 7)
+
+using namespace Napi;
+
+void Freeze(const CallbackInfo& info) {
+  Object obj = info[0].As<Object>();
+  obj.Freeze();
+}
+
+void Seal(const CallbackInfo& info) {
+  Object obj = info[0].As<Object>();
+  obj.Seal();
+}
+
+Object InitObjectFreezeSeal(Env env) {
+  Object exports = Object::New(env);
+  exports["freeze"] = Function::New(env, Freeze);
+  exports["seal"] = Function::New(env, Seal);
+  return exports;
+}
+
+#endif

test/object/object_freeze_seal.js

@@ -0,0 +1,38 @@
+'use strict';
+const buildType = process.config.target_defaults.default_configuration;
+const assert = require('assert');
+
+test(require(`../build/${buildType}/binding.node`));
+test(require(`../build/${buildType}/binding_noexcept.node`));
+
+function test(binding) {
+    {
+        const obj = { x: 'a', y: 'b', z: 'c' };
+        binding.object_freeze_seal.freeze(obj);
+        assert.strictEqual(Object.isFrozen(obj), true);
+        assert.throws(() => {
+          obj.x = 10;
+        }, /Cannot assign to read only property 'x' of object '#<Object>/);
+        assert.throws(() => {
+          obj.w = 15;
+        }, /Cannot add property w, object is not extensible/);
+        assert.throws(() => {
+          delete obj.x;
+        }, /Cannot delete property 'x' of #<Object>/);
+    }
+
+    {
+        const obj = { x: 'a', y: 'b', z: 'c' };
+        binding.object_freeze_seal.seal(obj);
+        assert.strictEqual(Object.isSealed(obj), true);
+        assert.throws(() => {
+          obj.w = 'd';
+        }, /Cannot add property w, object is not extensible/);
+        assert.throws(() => {
+          delete obj.x;
+        }, /Cannot delete property 'x' of #<Object>/);
+        // Sealed objects allow updating existing properties,
+        // so this should not throw.
+        obj.x = 'd';
+    }
+}