Separate library api and runtime components

red/runtime-api/flows.js

@@ -223,7 +223,7 @@ var api = module.exports = {
     */
     getNodeCredentials: function(opts) {
         return new Promise(function(resolve,reject) {
-            log.audit({event: "credentials.get",type:opts.type,id:opts.id});
+            runtime.log.audit({event: "credentials.get",type:opts.type,id:opts.id});
             var credentials = runtime.nodes.getCredentials(opts.id);
             if (!credentials) {
                 return resolve({});

red/runtime-api/index.js

@@ -30,6 +30,7 @@ var api = module.exports = {
         api.flows.init(runtime);
         api.nodes.init(runtime);
         api.settings.init(runtime);
+        api.library.init(runtime);
     },
 
     /**

red/runtime-api/library.js

@@ -15,21 +15,107 @@
  **/
 
 /**
- * @module red/library
+ * @namespace RED.library
  */
 
-module.exports = {
+var runtime;
+
+var api = module.exports = {
+    init: function(_runtime) {
+        runtime = _runtime;
+    },
 
     /**
-    * Does something
+    * Gets an entry from the library.
+    * @param {Object} opts
+    * @param {User} opts.user - the user calling the api
+    * @param {String} opts.type - the type of entry
+    * @param {String} opts.path - the path of the entry
+    * @return {Promise<String|Object>} - resolves when complete
+    * @memberof RED.library
     */
-    setEnty: function() {},
+    getEntry: function(opts) {
+        return new Promise(function(resolve,reject) {
+            runtime.library.getEntry(opts.type,opts.path).then(function(result) {
+                runtime.log.audit({event: "library.get",type:opts.type,path:opts.path});
+                return resolve(result);
+            }).catch(function(err) {
+                if (err) {
+                    runtime.log.warn(runtime.log._("api.library.error-load-entry",{path:opts.path,message:err.toString()}));
+                    if (err.code === 'forbidden') {
+                        err.status = 403;
+                        return reject(err);
+                    } else if (err.code === "not_found") {
+                        err.status = 404;
+                    } else {
+                        err.status = 400;
+                    }
+                    runtime.log.audit({event: "library.get",type:opts.type,path:opts.path,error:err.code});
+                    return reject(err);
+                }
+                runtime.log.audit({event: "library.get",type:type,error:"not_found"});
+                var error = new Error();
+                error.code = "not_found";
+                error.status = 404;
+                return reject(error);
+            });
+        })
+    },
+
     /**
-    * Does something
+    * Saves an entry to the library
+    * @param {Object} opts
+    * @param {User} opts.user - the user calling the api
+    * @param {String} opts.type - the type of entry
+    * @param {String} opts.path - the path of the entry
+    * @param {Object} opts.meta - any meta data associated with the entry
+    * @param {String} opts.body - the body of the entry
+    * @return {Promise} - resolves when complete
+    * @memberof RED.library
     */
-    getEntry: function() {},
+    saveEntry: function(opts) {
+        return new Promise(function(resolve,reject) {
+            runtime.library.saveEntry(opts.type,opts.path,opts.meta,opts.body).then(function() {
+                runtime.log.audit({event: "library.set",type:opts.type,path:opts.path});
+                return resolve();
+            }).catch(function(err) {
+                runtime.log.warn(runtime.log._("api.library.error-save-entry",{path:opts.path,message:err.toString()}));
+                    if (err.code === 'forbidden') {
+                    runtime.log.audit({event: "library.set",type:opts.type,path:opts.path,error:"forbidden"});
+                    err.status = 403;
+                    return reject(err);
+                }
+                runtime.log.audit({event: "library.set",type:opts.type,path:opts.path,error:"unexpected_error",message:err.toString()});
+                var error = new Error();
+                error.code = "not_found";
+                error.status = 400;
+                return reject(error);
+            });
+        })
+    },
     /**
-    * Does something
+    * Returns a complete listing of all entries of a given type in the library.
+    * @param {Object} opts
+    * @param {User} opts.user - the user calling the api
+    * @param {String} opts.type - the type of entry
+    * @return {Promise<Object>} - the entry listing
+    * @memberof RED.library
     */
-    getEntries: function() {}
+    getEntries: function(opts) {
+        return new Promise(function(resolve,reject) {
+            if (opts.type !== 'flows') {
+                return reject(new Error("API only supports flows"));
+
+            }
+            runtime.storage.getAllFlows().then(function(flows) {
+                runtime.log.audit({event: "library.get.all",type:"flow"});
+                var examples = runtime.nodes.getNodeExampleFlows();
+                if (examples) {
+                    flows.d = flows.d||{};
+                    flows.d._examples_ = examples;
+                }
+                return resolve(flows);
+            });
+        })
+    }
 }

red/runtime-api/nodes.js

@@ -14,27 +14,12 @@
  * limitations under the License.
  **/
 "use strict"
- /**
-  * @namespace RED.nodes
-  */
+/**
+ * @namespace RED.nodes
+ */
 
 var runtime;
 
-function putNode(node, enabled) {
-    var promise;
-    if (!node.err && node.enabled === enabled) {
-        promise = Promise.resolve(node);
-    } else {
-        if (enabled) {
-            promise = runtime.nodes.enableNode(node.id);
-        } else {
-            promise = runtime.nodes.disableNode(node.id);
-        }
-    }
-    return promise;
-}
-
-
 var api = module.exports = {
     init: function(_runtime) {
         runtime = _runtime;