Enabled Model.getOps() method #25470

src/bindings/js/node/CMakeLists.txt

@@ -68,6 +68,7 @@ add_library(${PROJECT_NAME} SHARED
     ${CMAKE_CURRENT_SOURCE_DIR}/src/addon.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/src/element_type.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/src/partial_shape_wrap.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/node_wrap.cpp
 
     ${CMAKE_JS_SRC}
 )

src/bindings/js/node/lib/addon.ts

@@ -257,6 +257,12 @@ interface Model {
    * @param index The index of the output.
    */
   getOutputElementType(index: number): string;
+
+  /**
+   * It gets the operations (nodes) of the model.
+   * @returns An array of Node objects representing the operations in the model.
+   */
+  getOps(): Node[];
   /**
    * It gets the input of the model.
    * If a model has more than one input, this method throws an exception.
@@ -309,6 +315,12 @@ interface Model {
   outputs: Output[];
 }
 
+interface Node {
+  /**
+   * It gets the name of the node.
+   */
+  getName(): string;
+}
 /**
  * CompiledModel represents a model that is compiled for a specific device
  * by applying multiple optimization transformations,

src/bindings/js/node/src/addon.cpp

@@ -30,6 +30,9 @@ void init_class(Napi::Env env,
     exports.Set(class_name, prototype);
 }
 
+Prototype func = NodeWrap::get_class()
+addon_data->node = Napi::Persistent(prototype);
+
 Napi::Value save_model_sync(const Napi::CallbackInfo& info) {
     std::vector<std::string> allowed_signatures;
     try {

src/bindings/js/node/src/model_wrap.cpp

@@ -8,6 +8,8 @@
 #include "node/include/helper.hpp"
 #include "node/include/node_output.hpp"
 #include "node/include/type_validation.hpp"
+#include "model_wrap.h"
+#include "node_wrap.h"
 
 ModelWrap::ModelWrap(const Napi::CallbackInfo& info)
     : Napi::ObjectWrap<ModelWrap>(info),
@@ -204,3 +206,12 @@ Napi::Value ModelWrap::clone(const Napi::CallbackInfo& info) {
         return info.Env().Undefined();
     }
 }
+
+Napi::Value ModelWrap::get_ops(const Napi::CallbackInfo& info) {
+    std::vector<ov::Node*> ops = this->model_->get_ops();
+    Napi::Array result = Napi::Array::New(info.Env(), ops.size());
+    for (size_t i = 0; i < ops.size(); i++) {
+        result[i] = NodeWrap::New(info.Env(), ops[i]);
+    }
+    return result;
+}

src/bindings/js/node/src/node_wrap.cpp

@@ -0,0 +1,32 @@
+#include "node_wrap.h"
+
+Napi::FunctionReference NodeWrap::constructor;
+
+//NodeWrap
+NodeWrap::NodeWrap(const Napi::CallbackInfo& info, ov::Node* node) : Napi::ObjectWrap<NodeWrap>(info) {
+    this->node_ = node;
+}
+
+Napi::Value NodeWrap::get_name(const Napi::CallbackInfo& info) {
+    return Napi::String::New(info.Env(), this->node_->get_name());
+}
+
+Napi::Object NodeWrap::New(Napi::Env env, ov::Node* node) {
+    Napi::Object obj = Napi::ObjectWrap<NodeWrap>::New(env, node);
+    return obj;
+}
+
+Napi::Object Init(Napi::Env env, Napi::Object exports) {
+    Napi::Function func = DefineClass(env, "Node", {
+      InstanceMethod("getName", &NodeWrap::get_name),
+    }, [](const Napi::CallbackInfo& info) {
+        ov::Node* node = info[0].As<Napi::External<ov::Node>>().Data();
+        return NodeWrap::New(env, node);
+    });
+
+    constructor = Napi::Persistent(func);
+    exports.Set("Node", func);
+    return exports;
+}
+
+NODE_API_MODULE(Node, Init)

src/bindings/js/node/src/node_wrap.hpp

@@ -0,0 +1,24 @@
+#pragma once
+#include <napi.h>
+#include <ov/node.hpp>
+
+#include <openvino/openvino.hpp>
+
+class NodeWrap : public Napi::ObjectWrap<NodeWrap> {
+public:
+    /**
+     * constructor
+     * @brief Constructs NodeWrap from the Napi::CallbackInfo.
+     * @param info contains passed arguments. Can be empty.
+     * @param node pointer to ov::Node object.
+     */
+    NodeWrap(const Napi::CallbackInfo& info, ov::Node* node);
+
+    // member functions
+    Napi::Value get_name(const Napi::CallbackInfo& info);
+
+private:
+    ov::Node* node_;
+};
+
+#endif //NODE_WRAP_H

src/bindings/js/node/tests/unit/model.test.js

@@ -192,4 +192,31 @@ describe('ov.Model tests', () => {
       );
     });
   });
+
+  describe('Node.js Model.getOps()', () => {
+    it('should return array of Node operations', () => {
+      const result = model.getOps();
+
+      assert(Array.isArray(result), 'getOps should return an array');
+      assert(result.length > 0, 'getOps should return a non-empty array');
+      result.forEach(op => {
+        assert.strictEqual(typeof op.getName, 'function', 'each item should have getName method');
+      });
+    });
+
+    it('should return the expected operation', () => {
+      const result = model.getOps();
+
+      const modelOperators = result.map(op => op.getName().split('_')[0]);
+      const expectedOpsCount = 14;
+      const expectedOps = [
+        "Subtract",
+        "Transpose",
+      ];
+
+      assert.strictEqual(modelOperators.length, expectedOpsCount, `Expected ${expectedOpsCount} operations in the model`);
+      expectedOps.forEach(op => {
+        assert(modelOperators.includes(op), `Expected operation ${op} to be in the model`);
+      });
+    });
 });