Source: ogmneo-node.js

  1. 'use strict';
  3. const _ = require('lodash');
  5. const OGMNeoQuery = require('./ogmneo-query');
  6. const OGMNeoObjectParse = require('./ogmneo-parse');
  7. const { OGMNeoOperation, OGMNeoOperationBuilder } = require('./ogmneo-operation');
  8. const OGMNeoOperationExecuter = require('./ogmneo-operation-executer');
  10. /**
  11.     * @class OGMNeoNode
  12.  */
  13. class OGMNeoNode {
  14.     /**
  15.         * Creates a node on neo4j.
  16.         *
  17.         * @static
  18.         * @param {object} node - The literal object with node propeperties.
  19.         * @param {string} [label=null] - The label of the node. Default null is a node without label. 
  20.         * @returns {Promise<object|Error>} Created node literal object if fulfilled, or some neo4j error if rejected.
  21.     */
  22.     static create(node, label = null) {
  23.         let operation = this.createOperation(node, label);
  24.         return OGMNeoOperationExecuter.execute(operation);
  25.     }
  27.     /**
  28.         * Operation that creates a node on neo4j.
  29.         *
  30.         * @static
  31.         * @param {object} node - The literal object with node propeperties.
  32.         * @param {string} [label=null] - The label of the node. Default null is a node without label. 
  33.         * @returns {OGMNeoOperation} Create node operation that can be executed later.
  34.     */
  36.     static createOperation(node, label = null) {
  37.         let value = _.omitBy(node, _.isUndefined);
  38.         OGMNeoObjectParse.parseProperties(value);
  39.         let objectString = OGMNeoObjectParse.objectString(value);
  40.         let labelCypher = (!_.isEmpty(label) && _.isString(label)) ? `:${label}` : '';
  41.         let cypher = `CREATE (n${labelCypher} ${objectString}) RETURN n`;
  42.         return OGMNeoOperationBuilder.create()
  43.             .cypher(cypher)
  44.             .object(value)
  45.             .type(OGMNeoOperation.WRITE).then((result) => {
  46.                 let record = _.first(result.records);
  47.                 return OGMNeoObjectParse.parseRecordNode(record, 'n');
  48.             }).build();
  49.     }
  51.     /**
  52.         * Updates a node on neo4j.
  53.         *
  54.         * @static
  55.         * @param {object} node - The literal object with node propeperties and required node.id.
  56.         * @returns {Promise.<object|Error>} Updated node literal object if fulfilled, or error if node.id is invalid or some neo4j error if rejected.
  57.     */
  58.     static update(node) {
  59.         try {
  60.             let operation = this.updateOperation(node);
  61.             return OGMNeoOperationExecuter.execute(operation);
  62.         } catch (error) {
  63.             return Promise.reject(error);
  64.         }
  65.     }
  67.     /**
  68.         * Operation that updates a node.
  69.         *
  70.         * @static
  71.         * @param {object} node - The literal object with node propeperties and required node.id.
  72.         * @returns {OGMNeoOperation} Update node operation that can be executed later.
  73.         * @throws {Error} Will throw an error if the node.id was not integer or not exists.
  74.     */
  75.     static updateOperation(node) {
  76.         let value = _.omitBy(node, _.isUndefined);
  77.         OGMNeoObjectParse.parseProperties(value);
  78.         if (value && value.id != undefined && _.isInteger(value.id)) {
  79.             let objectString = OGMNeoObjectParse.objectString(value);
  80.             let cypher = `MATCH (n) WHERE ID(n)=${node.id} SET n+=${objectString} RETURN n`;
  81.             return OGMNeoOperationBuilder.create()
  82.                 .cypher(cypher)
  83.                 .object(value)
  84.                 .type(OGMNeoOperation.WRITE).then((result) => {
  85.                     let record = _.first(result.records);
  86.                     return OGMNeoObjectParse.parseRecordNode(record, 'n');
  87.                 }).build();
  88.         } else {
  89.             throw new Error('Node must have an integer id to be updated');
  90.         }
  91.     }
  93.     /**
  94.         * Update new properties on every node that matches the query.
  95.         *
  96.         * @static
  97.         * @param {OGMNeoQuery} query - The query to filter the nodes.
  98.         * @param {object} newProperties - NEW properties.
  99.         * @returns {Promise.<array|Error>} Updated nodes if fulfilled or some neo4j error if rejected.
  100.     */
  101.     static updateMany(query, newProperties) {
  102.         try {
  103.             let operation = this.updateManyOperation(query, newProperties);
  104.             return OGMNeoOperationExecuter.execute(operation);
  105.         } catch (error) {
  106.             return Promise.reject(error);
  107.         }
  108.     }
  110.     /**
  111.           * Returns an operation that updates new properties on every node that matches the query.
  112.           *
  113.           * @static
  114.           * @param {OGMNeoQuery} query - The query to filter the nodes.
  115.           * @param {object} newProperties - NEW properties.
  116.           * @returns {OGMNeoOperation} Operation that updates new properties on every node that matches the query.
  117.           * @throws {Error} Will throw an error if the query is not an instance of ogmneo.Query.
  118.           * @throws {Error} Will throw an error if newProperties is not an object.
  119.           * @throws {Error} Will throw an error if newProperties don't have at least one property with NO undefined values to update.
  120.       */
  121.     static updateManyOperation(query, newProperties) {
  122.         if (_.isObject(newProperties)) {
  123.             let value = _.omitBy(newProperties, _.isUndefined);
  124.             if (!_.isEmpty(value)) {
  125.                 OGMNeoObjectParse.parseProperties(value);
  126.                 if (query instanceof OGMNeoQuery) {
  127.                     let objectString = OGMNeoObjectParse.objectString(value);
  128.                     let cypher = `${query.matchCypher()} SET n+=${objectString} RETURN n`;
  129.                     return OGMNeoOperationBuilder.create()
  130.                         .cypher(cypher)
  131.                         .object(value)
  132.                         .type(OGMNeoOperation.WRITE).then((result) => {
  133.                             return result.records.map(record => OGMNeoObjectParse.parseRecordNode(record, 'n'));
  134.                         }).build();
  135.                 } else {
  136.                     throw new Error('The query object must be an instance of OGMNeoQuery');
  137.                 }
  138.             } else {
  139.                 throw new Error('You must provide at least one property with NO undefined values to update');
  140.             }
  141.         } else {
  142.             throw new Error('The new properties must be an object');
  143.         }
  144.     }
  146.     /**
  147.         * Deletes a node on neo4j.
  148.         *
  149.         * @static
  150.         * @param {object} node - The literal object with node propeperties and required node.id.
  151.         * @returns {Promise.<boolean|Error>} True if fulfilled and found and delete node, false if not found object to delete, or error if node.id is invalid or some neo4j error if rejected.
  152.     */
  153.     static delete(node) {
  154.         try {
  155.             let operation = this.deleteOperation(node);
  156.             return OGMNeoOperationExecuter.execute(operation);
  157.         } catch (error) {
  158.             return Promise.reject(error);
  159.         }
  160.     }
  162.     /**
  163.         * Operation that deletes a node on neo4j.
  164.         *
  165.         * @static
  166.         * @param {object} node - The literal object with node propeperties and required node.id.
  167.         * @returns {OGMNeoOperation} Operation that deletes a node.
  168.         * @throws {Error} Will throw an error if the node.id was not integer or not exists.
  169.     */
  170.     static deleteOperation(node) {
  171.         if (node && node.id != undefined && _.isInteger(node.id)) {
  172.             let cypher = `MATCH (n) WHERE ID(n)=${node.id} DELETE n RETURN n`;
  173.             return OGMNeoOperationBuilder.create()
  174.                 .cypher(cypher)
  175.                 .type(OGMNeoOperation.WRITE).then((result) => {
  176.                     return !_.isEmpty(result.records);
  177.                 }).build();
  178.         } else {
  179.             throw new Error('Node must to have an non-nil property id to be deleted');
  180.         }
  181.     }
  183.     /**
  184.         * Deletes a node and it's relation from database.
  185.         *
  186.         * @static
  187.         * @param {object} node - The literal object with node propeperties and required node.id.
  188.         * @returns {Promise.<boolean|Error>} True if fulfilled and found and delete node, false if not found object to delete, or error if node.id is invalid or some neo4j error if rejected.
  189.     */
  190.     static deleteCascade(node) {
  191.         try {
  192.             let operation = this.deleteCascadeOperation(node);
  193.             return OGMNeoOperationExecuter.execute(operation);
  194.         } catch (error) {
  195.             return Promise.reject(error);
  196.         }
  197.     }
  199.     /**
  200.         * Operation that deletes a node and it's relation from database.
  201.         *
  202.         * @static
  203.         * @param {object} node - The literal object with node propeperties and required node.id.
  204.         * @returns {OGMNeoOperation} Operation that deletes a node.
  205.         * @throws {Error} Will throw an error if the node.id was not integer or not exists.
  206.     */
  207.     static deleteCascadeOperation(node) {
  208.         if (node && node.id != undefined && _.isInteger(node.id)) {
  209.             let cypher = `MATCH (n) WHERE ID(n)=${node.id} DETACH DELETE n RETURN n`;
  210.             return OGMNeoOperationBuilder.create()
  211.                 .cypher(cypher)
  212.                 .type(OGMNeoOperation.WRITE).then((result) => {
  213.                     return !_.isEmpty(result.records);
  214.                 }).build();
  215.         } else {
  216.             throw new Error('Node must to have an non-nil property id to be deleted');
  217.         }
  218.     }
  220.     /**
  221.         * Deletes every node that matches the ogmneo.Query.
  222.         *
  223.         * @static
  224.         * @param {OGMNeoQuery} query - The query to filter the nodes.
  225.         * @returns {Promise.<number|Error>} Number of nodes deleted if fulfilled or some neo4j error if rejected.
  226.     */
  227.     static deleteMany(query) {
  228.         try {
  229.             let operation = this.deleteManyOperation(query);
  230.             return OGMNeoOperationExecuter.execute(operation);
  231.         } catch (error) {
  232.             return Promise.reject(error);
  233.         }
  234.     }
  236.     /**
  237.         * Creates an operation that deletes every node that matches the query.
  238.         *
  239.         * @static
  240.         * @param {OGMNeoQuery} query - The query to filter the nodes.
  241.         * @returns {OGMNeoOperation} Operation that deletes the matched nodes.
  242.         * @throws {Error} Will throw an error if the query was not a instance of ogmneo.Query.
  243.     */
  244.     static deleteManyOperation(query) {
  245.         if (query instanceof OGMNeoQuery) {
  246.             let cypher = `${query.matchCypher()} DELETE n RETURN n`;
  247.             return OGMNeoOperationBuilder.create()
  248.                 .cypher(cypher)
  249.                 .type(OGMNeoOperation.WRITE)
  250.                 .then((result) => {
  251.                     return result.records.length;
  252.                 }).build();
  253.         } else {
  254.             throw new Error('The query object must be an instance of OGMNeoQuery');
  255.         }
  256.     }
  258.     /**
  259.         * Retrive node with id.
  260.         *
  261.         * @static
  262.         * @param {integer} id - The id of node that's wanted.
  263.         * @returns {Promise.<object|Error>} Object if found fulfilled or null if not found fulfilled, or error if the id is invalid or some neo4j error if rejected.
  264.     */
  265.     static nodeWithId(id) {
  266.         try {
  267.             let operation = this.nodeWithIdOperation(id);
  268.             return OGMNeoOperationExecuter.execute(operation);
  269.         } catch (error) {
  270.             return Promise.reject(error);
  271.         }
  272.     }
  274.     /**
  275.         * Creates a operation that retrives a node with id.
  276.         *
  277.         * @static
  278.         * @param {integer} id - The id of node that's wanted.
  279.         * @returns {OGMNeoOperation} Operation retrives a node.
  280.         * @throws {Error} Will throw an error if id was not an integer value.
  281.     */
  282.     static nodeWithIdOperation(id) {
  283.         if (_.isInteger(id)) {
  284.             let cypher = `MATCH (n) WHERE ID(n)=${id} RETURN n`;
  285.             return OGMNeoOperationBuilder.create()
  286.                 .cypher(cypher)
  287.                 .type(OGMNeoOperation.READ)
  288.                 .then((result) => {
  289.                     let record = _.first(result.records);
  290.                     return OGMNeoObjectParse.parseRecordNode(record, 'n');
  291.                 }).build();
  292.         } else {
  293.             throw new Error('You must provide an non-null integer id property to find the node');
  294.         }
  295.     }
  297.     /**
  298.         * Retrive nodes with ids.
  299.         *
  300.         * @static
  301.         * @param {array} ids - The ids of nodes that are wanted.
  302.         * @returns {Promise.<array|Error>} An array of nodes if found fulfilled or null if not found fulfilled, or error if the ids are invalid or some neo4j error if rejected.
  303.     */
  304.     static manyWithIds(ids) {
  305.         try {
  306.             let operation = this.manyWithIdsOperation(ids);
  307.             return OGMNeoOperationExecuter.execute(operation);
  308.         } catch (error) {
  309.             return Promise.reject(error);
  310.         }
  311.     }
  313.     /**
  314.         * Operation to retrive nodes with ids.
  315.         *
  316.         * @static
  317.         * @param {array} ids - The ids of nodes that are wanted.
  318.         * @returns {OGMNeoOperation} Operation that query the nodes with the ids.
  319.         * @throws {Error} Will throw an error if you don't provide any valid id to retrive.
  320.         * @throws {Error} Will throw an error if the ids are not an array.
  322.     */
  323.     static manyWithIdsOperation(ids) {
  324.         if (_.isArray(ids)) {
  325.             let validIds = ids.filter(id => _.isInteger(id));
  326.             if (_.isEmpty(validIds)) {
  327.                 throw new Error('You must provide at least one valid(integer) id to query');
  328.             } else {
  329.                 let idsQuery = validIds.reduce((result, current) => {
  330.                     return result + ((result === '') ? '' : ',') + ` ${current}`;
  331.                 }, '');
  332.                 let cypher = `MATCH (n) WHERE ID(n) IN [${idsQuery}] RETURN n`;
  333.                 return OGMNeoOperationBuilder.create()
  334.                     .cypher(cypher)
  335.                     .type(OGMNeoOperation.READ)
  336.                     .then((result) => {
  337.                         return result.records.map(record => OGMNeoObjectParse.parseRecordNode(record, 'n'));
  338.                     }).build();
  339.             }
  340.         } else {
  341.             throw new Error('The parameter must be an array of ids');
  342.         }
  343.     }
  345.     /**
  346.         * Count of nodes with the label.
  347.         *
  348.         * @static
  349.         * @param {string} label - The label of nodes that have to be counted.
  350.         * @returns {Promise.<integer|Error>} Count of nodes if fulfilled, some neo4j error if rejected.
  351.     */
  352.     static countWithLabel(label) {
  353.         return this.count(new OGMNeoQuery(label));
  354.     }
  356.     /**
  357.         * Count of nodes with the query.
  358.         *
  359.         * @static
  360.         * @param {OGMNeoQuery} query - The query to filter nodes that have to be counted.
  361.         * @returns {Promise.<integer|Error>} Count of nodes if fulfilled, some neo4j error if rejected.
  362.     */
  363.     static count(query) {
  364.         try {
  365.             let operation = this.countOperation(query);
  366.             return OGMNeoOperationExecuter.execute(operation);
  367.         } catch (error) {
  368.             return Promise.reject(error);
  369.         }
  370.     }
  372.     /**
  373.         * Creates an operation count of nodes with a query object.
  374.         *
  375.         * @static
  376.         * @param {OGMNeoQuery} query - The query to filter nodes that have to be counted.
  377.         * @returns {OGMNeoOperation} Operation that query the count of the nodes with query.
  378.         * @throws {Error} Will throw an error if the query was not a instance of ogmneo.Query.
  379.     */
  380.     static countOperation(query) {
  381.         if (query && query instanceof OGMNeoQuery) {
  382.             let cypher = query.countCypher();
  383.             return OGMNeoOperationBuilder.create()
  384.                 .cypher(cypher)
  385.                 .type(OGMNeoOperation.READ)
  386.                 .then((result) => {
  387.                     let record = _.first(result.records);
  388.                     return (record != null) ? record.get('count').low : 0;
  389.                 }).build();
  390.         } else {
  391.             throw new Error('A OGMNeoQuery object must to be provided');
  392.         }
  393.     }
  395.     /**
  396.         * Find nodes filtered by query parameter.
  397.         *
  398.         * @static
  399.         * @param {OGMNeoQuery} query - The query to filter nodes that have to be returned.
  400.         * @returns {Promise.<array|Error>} Nodes if fulfilled, some neo4j error if rejected.
  401.     */
  402.     static find(query) {
  403.         try {
  404.             let operation = this.findOperation(query);
  405.             return OGMNeoOperationExecuter.execute(operation);
  406.         } catch (error) {
  407.             return Promise.reject(error);
  408.         }
  409.     }
  412.     /**
  413.         * Operation for find nodes filtered by the query parameter.
  414.         *
  415.         * @static
  416.         * @param {OGMNeoQuery} query - The query to filter nodes that have to be returned.
  417.         * @returns {OGMNeoOperation} Operation that returns the nodes with query.
  418.         * @throws {Error} Will throw an error if the query was not a instance of ogmneo.Query.
  419.     */
  420.     static findOperation(query) {
  421.         if (query && query instanceof OGMNeoQuery) {
  422.             let cypher = query.queryCypher();
  423.             return OGMNeoOperationBuilder.create()
  424.                 .cypher(cypher)
  425.                 .type(OGMNeoOperation.READ)
  426.                 .then((result) => {
  427.                     return result.records.map((record) => OGMNeoObjectParse.parseRecordNode(record, 'n'));
  428.                 }).build();
  429.         } else {
  430.             throw new Error('A OGMNeoQuery object must to be provided');
  431.         }
  432.     }
  434.     /**
  435.         * Find one node filtered by query parameter. Will return the first node that it finds.
  436.         *
  437.         * @static
  438.         * @param {OGMNeoQuery} query - The query to filter nodes that have to be returned.
  439.         * @returns {Promise.<object|Error>} Node found if fulfilled, some neo4j error if rejected.
  440.     */
  441.     static findOne(query) {
  442.         try {
  443.             let operation = this.findOneOperation(query);
  444.             return OGMNeoOperationExecuter.execute(operation);
  445.         } catch (error) {
  446.             return Promise.reject(error);
  447.         }
  448.     }
  450.     /**
  451.         * Operation that find one node filtered by query parameter.
  452.         *
  453.         * @static
  454.         * @param {OGMNeoQuery} query  The query to filter nodes that have to be returned.
  455.         * @returns {OGMNeoOperation} Operation that returns the node with query.
  456.         * @throws {Error} Will throw an error if the query was not a instance of ogmneo.Query.
  457.     */
  458.     static findOneOperation(query) {
  459.         if (query && query instanceof OGMNeoQuery) {
  460.             query.limit(1);
  461.             return OGMNeoOperationBuilder.create()
  462.                 .cypher(query.queryCypher())
  463.                 .type(OGMNeoOperation.READ)
  464.                 .then((result) => {
  465.                     let record = _.first(result.records);
  466.                     return (record != null) ? OGMNeoObjectParse.parseRecordNode(record, 'n') : null;
  467.                 }).build();
  468.         } else {
  469.             throw new Error('A OGMNeoQuery object must to be provided');
  470.         }
  471.     }
  472.     /**
  473.         * Adding label to a node.
  474.         *
  475.         * @static
  476.         * @param {string} label - The label to be added to the node.
  477.         * @param {integer} nodeId - The id of the node to add the label.
  478.         * @returns {Promise.<object|Error>} Node(if node exists) or null(if not exists) if fulfilled, some error if rejected.
  479.     */
  480.     static addLabelToNode(label, nodeId) {
  481.         try {
  482.             let operation = this.addLabelToNodeOperation(label, nodeId);
  483.             return OGMNeoOperationExecuter.execute(operation);
  484.         } catch (error) {
  485.             return Promise.reject(error);
  486.         }
  487.     }
  489.     /**
  490.         * Operation to add a label to a node.
  491.         *
  492.         * @static
  493.         * @param {string} label - The label to be added to the node.
  494.         * @param {integer} nodeId - The id of the node to add the label.
  495.         * @returns {OGMNeoOperation} Operation that adds a label.
  496.         * @throws {Error} Will throw an error if the nodeId was not an integer value.
  497.         * @throws {Error} Will throw an error if the label was anything diferent than an non-empty string.
  498.     */
  499.     static addLabelToNodeOperation(label, nodeId) {
  500.         if (_.isInteger(nodeId)) {
  501.             let operation = this.addLabelToNodesOperation(label, [nodeId]);
  502.             operation.then = (result) => {
  503.                 let record = _.first(result.records);
  504.                 return (record != null) ? OGMNeoObjectParse.parseRecordNode(record, 'n') : null; 
  505.             };
  506.             return operation;
  507.         } else {
  508.             throw new Error('The nodeId must be an integer value');
  509.         }
  510.     }
  512.     /**
  513.         * Remove label from a node.
  514.         *
  515.         * @static
  516.         * @param {string} label - The label to be removed from the node.
  517.         * @param {integer} nodeId - The id of the node to remove the label from.
  518.         * @returns {Promise.<object|Error>} Node(if node exists) or null(if not exists) if fulfilled, some error if rejected.
  519.     */
  520.     static removeLabelFromNode(label, nodeId) {
  521.         try {
  522.             let operation = this.removeLabelFromNodeOperation(label, nodeId);
  523.             return OGMNeoOperationExecuter.execute(operation);
  524.         } catch (error) {
  525.             return Promise.reject(error);
  526.         }
  527.     }
  529.     /**
  530.         *  Operation to remove a label from a node.
  531.         *
  532.         * @static
  533.         * @param {string} label - The label to be removed from the node.
  534.         * @param {integer} nodeId - The id of the node to remove the label from.
  535.         * @returns {OGMNeoOperation} Operation that removes a label.
  536.         * @throws {Error} Will throw an error if the nodeId was not an integer value.
  537.         * @throws {Error} Will throw an error if the label was anything diferent than an non-empty string.
  538.     */
  539.     static removeLabelFromNodeOperation(label, nodeId) {
  540.         if (_.isInteger(nodeId)) {
  541.             let operation = this.removeLabelFromNodesOperation(label, [nodeId]);
  542.             operation.then = (result) => {
  543.                 let record = _.first(result.records);
  544.                 return (record != null) ? OGMNeoObjectParse.parseRecordNode(record, 'n') : null; 
  545.             };
  546.             return operation;
  547.         } else {
  548.             throw new Error('The nodeId must be an integer value');
  549.         }
  550.     }
  552.     /**
  553.         * Adding label to nodes.
  554.         *
  555.         * @static
  556.         * @param {string} label - The label to be added to the node.
  557.         * @param {array} nodesIds - The ids of the nodes to add the label.
  558.         * @returns {Promise<array|Error>} Nodes(if nodes exists) or null(if not exists) if fulfilled, some error if rejected.
  559.     */
  560.     static addLabelToNodes(label, nodesIds) {
  561.         try {
  562.             let operation = this.addLabelToNodesOperation(label, nodesIds);
  563.             return OGMNeoOperationExecuter.execute(operation);
  564.         } catch (error) {
  565.             return Promise.reject(error);
  566.         }
  567.     }
  569.     /**
  570.         * Operation that adds a label to nodes.
  571.         *
  572.         * @static
  573.         * @param {string} label - The label to be added to the node.
  574.         * @param {array} nodesIds - The ids of the nodes to add the label.
  575.         * @returns {OGMNeoOperation} Operation that removes a label.
  576.         * @throws {Error} Will throw an error if you don't provide at least one valid id to this operation.
  577.         * @throws {Error} Will throw an error if the label was anything diferent than an non-empty string.
  578.     */
  579.     static addLabelToNodesOperation(label, nodesIds) {
  580.         if (_.isString(label) && !_.isEmpty(label)) {
  581.             let params = this._validateAndBuildParams(nodesIds);
  582.             if (params != null) {
  583.                 let cypher = `MATCH (n) WHERE ID(n) IN ${params} SET n:${label} RETURN n`;
  584.                 return OGMNeoOperationBuilder
  585.                     .create()
  586.                     .cypher(cypher)
  587.                     .type(OGMNeoOperation.WRITE)
  588.                     .then((result) => {
  589.                         return result.records.map(record => OGMNeoObjectParse.parseRecordNode(record, 'n'));
  590.                     }).build();
  591.             } else {
  592.                 throw new Error('You must provide at least one valid id to this operation');
  593.             }
  594.         } else {
  595.             throw new Error('label must be a non empty string');
  596.         }
  597.     }
  599.     /**
  600.         * Remove label from nodes.
  601.         *
  602.         * @static
  603.         * @param {string} label - The label to be removed from the nodes.
  604.         * @param {array} nodeIds - The ids of the nodes to remove the label from.
  605.         * @returns {Promise.<array|Error>} Nodes(if nodes exists) or null(if not exists) if fulfilled, some error if rejected.
  606.     */
  607.     static removeLabelFromNodes(label, nodesIds) {
  608.         try {
  609.             let operation = this.removeLabelFromNodesOperation(label, nodesIds);
  610.             return OGMNeoOperationExecuter.execute(operation);
  611.         } catch (error) {
  612.             return Promise.reject(error);
  613.         }
  614.     }
  616.     /**
  617.         * Operation that removes a label from nodes.
  618.         *
  619.         * @static
  620.         * @param {string} label - The label to be removed from the nodes.
  621.         * @param {array} nodeIds - The ids of the nodes to remove the label from.
  622.         * @returns {OGMNeoOperation} Operation that removes a label from many nodes.
  623.         * @throws {Error} Will throw an error if you don't provide at least one valid id to this operation.
  624.         * @throws {Error} Will throw an error if the label was anything diferent than an non-empty string.
  625.     */
  626.     static removeLabelFromNodesOperation(label, nodesIds) {
  627.         if (_.isString(label) && !_.isEmpty(label)) {
  628.             let params = this._validateAndBuildParams(nodesIds);
  629.             if (params) {
  630.                 let cypher = `MATCH (n:${label}) WHERE ID(n) IN ${params} REMOVE n:${label} RETURN n`;
  631.                 return OGMNeoOperationBuilder
  632.                     .create()
  633.                     .cypher(cypher)
  634.                     .type(OGMNeoOperation.WRITE)
  635.                     .then((result) => {
  636.                         return result.records.map(record => OGMNeoObjectParse.parseRecordNode(record, 'n'));
  637.                     }).build();
  638.             } else {
  639.                 throw new Error('You must provide at least one valid id to this operation');
  640.             }
  641.         } else {
  642.             throw new Error('label must be a non empty string');
  643.         }
  644.     }
  646.     static _validateAndBuildParams(nodesIds) {
  647.         if (_.isArray(nodesIds)) {
  648.             let validIds = nodesIds.filter(id => _.isInteger(id));
  649.             if (_.isEmpty(validIds)) {
  650.                 return null;
  651.             } else {
  652.                 let parameters = validIds.reduce((result, current) => {
  653.                     return result + `${(result === '') ? '' : ','} ${current}`;
  654.                 }, '');
  655.                 return `[${parameters}]`;
  656.             }
  657.         } else {
  658.             throw new Error('nodesIds must be an array');
  659.         }
  660.     }
  661. }
  663. module.exports = OGMNeoNode;