pathchain 1.0.60 → 1.1.0

package/maker.js

@@ -1,422 +1,376 @@
-var fs = require("fs");
-var pb = require('protocol-buffers');
-var dt = require('date-and-time');
-var sha256 = require("js-sha256");
+// Required modules
+const fs = require("fs");
+const pb = require('protocol-buffers');
+const dt = require('date-and-time');
+const sha256 = require("js-sha256");
 const getter = require("./getter");
 const checker = require("./checker");
 const updater = require("./updater");
 
-/** moment
- * [Moment Protocol Buffer Creation]
- * 
- * @param {string} datetime (optional)
- * @param {float}  lat      (optional)
- * @param {float}  lon      (optional)
- * @param {float}  x        (optional)
- * @param {float}  y        (optional)
- * @param {float}  z        (optional)
- * @param {string} format   (optional)
- * 
- * @return {string} moment_buffer
+/**
+ * Creates a moment Protocol Buffer
+ * @param {string} datetime - Timestamp (optional)
+ * @param {number} lat - Latitude (optional)
+ * @param {number} lon - Longitude (optional)
+ * @param {number} x - X coordinate (optional)
+ * @param {number} y - Y coordinate (optional)
+ * @param {number} z - Z coordinate (optional)
+ * @param {string} format - Date format (optional)
+ * @returns {string} moment_hash - Hash of the created moment
  */
 function moment(datetime, lat, lon, x, y, z, format) {
-    var moment_pb = pb(fs.readFileSync('node_modules/pathchain/proto/moment.proto'));
+    const moment_pb = pb(fs.readFileSync('node_modules/pathchain/proto/moment.proto'));
     
-    var date_obj = dt.preparse(datetime, format);
-    var moment_obj = {
+    const date_obj = dt.preparse(datetime, format);
+    const moment_obj = {
         coordinates: {
             lat: lat,
             lon: lon,
             xyz: { x: x, y: y, z: z }
         },
         datetime: {
-            Y: date_obj.Y,
-            M: date_obj.M,
-            D: date_obj.D,
-            H: date_obj.H,
-            A: date_obj.A,
-            h: date_obj.h,
-            m: date_obj.m,
-            s: date_obj.s,
-            S: date_obj.S,
-            Z: date_obj.Z,
-            _index: date_obj._index,
-            _length: date_obj._length,
-            _match: date_obj._match
+            Y: date_obj.Y, M: date_obj.M, D: date_obj.D,
+            H: date_obj.H, A: date_obj.A, h: date_obj.h,
+            m: date_obj.m, s: date_obj.s, S: date_obj.S,
+            Z: date_obj.Z, _index: date_obj._index,
+            _length: date_obj._length, _match: date_obj._match
         }
-    }
+    };
 
-    var buffer = moment_pb.moment.encode(moment_obj);
-    
-    var moment_hash = sha256(JSON.stringify(moment_pb.moment.decode(buffer)));
+    const buffer = moment_pb.moment.encode(moment_obj);
+    const moment_hash = sha256(JSON.stringify(moment_pb.moment.decode(buffer)));
 
     checker.checkDir("files/moments/");
-    fs.writeFileSync("files/moments/" + moment_hash, buffer);
+    fs.writeFileSync(`files/moments/${moment_hash}`, buffer);
 
     return moment_hash;
 }
 
-/** secret
- * [Pioneer Protocol Buffer Creation]
- * 
- * @param {string} author (optional, default=pioneer_hash)
- * @param {string} format   (required)
- * 
- * @return {string} secret_hash
+/**
+ * Creates a secret Protocol Buffer
+ * @param {string} author - Author of the secret (optional, default=pioneer_hash)
+ * @param {string} format - Date format (required)
+ * @returns {string} secret_hash - Hash of the created secret
  */
 function secret(author, format) {
-    checker.checkDir("files/entities/")
-
-    // There is no pioneer
-    if(checker.checkEmptyDir("files/entities/")){
-        var secret_pb = pb(fs.readFileSync('node_modules/pathchain/proto/secret.proto'))
+    checker.checkDir("files/entities/");
 
-        var register = new Date()
-        register = dt.format(register, dt.compile(format, true));
+    // Create secret only if there's no pioneer yet
+    if (checker.checkEmptyDir("files/entities/")) {
+        const secret_pb = pb(fs.readFileSync('node_modules/pathchain/proto/secret.proto'));
 
-        var register_moment_hash = moment(register, 0, 0, 0, 0, 0, format)
+        const register = dt.format(new Date(), dt.compile(format, true));
+        const register_moment_hash = moment(register, 0, 0, 0, 0, 0, format);
         
-        var secret_hash = sha256(register_moment_hash + "_" + author);
+        const secret_hash = sha256(`${register_moment_hash}_${author}`);
         
-        var buffer = secret_pb.secret.encode({
-            register: "moments/"+register_moment_hash,
-            author: "entities/"+author,
-            user: "entities/"+author,
+        const buffer = secret_pb.secret.encode({
+            register: `moments/${register_moment_hash}`,
+            author: `entities/${author}`,
+            user: `entities/${author}`,
             used: false,
-            tag: "secrets/"+secret_hash,
-        })
+            tag: `secrets/${secret_hash}`,
+        });
 
-        checker.checkDir("files/secrets/") // checking
-        checker.checkDir("files/"+ author +"/secrets/") // checking
+        checker.checkDir("files/secrets/");
+        checker.checkDir(`files/${author}/secrets/`);
 
-        fs.writeFileSync("files/secrets/" + secret_hash, buffer);
-        fs.writeFileSync("files/"+ author +"/secrets/" + secret_hash, buffer);
+        fs.writeFileSync(`files/secrets/${secret_hash}`, buffer);
+        fs.writeFileSync(`files/${author}/secrets/${secret_hash}`, buffer);
         
         return secret_hash;
-    }
-    // The pioneer already exists
-    else{
+    } else {
         return "The pioneer has only one secret";
     }
 }
 
-/** pioneer
- * [Pioneer Protocol Buffer Creation]
- * 
- * @param {string} xbigbang (required) // The creation moment is the bigbang of the system
- * @param {string} format   (required)
- * 
- * @return {string} pioneer_buffer
+/**
+ * Creates the pioneer (first entity) Protocol Buffer
+ * @param {string} xbigbang - The creation moment (required)
+ * @param {string} format - Date format (required)
+ * @returns {string} pioneer_hash - Hash of the created pioneer
  */
 function pioneer(xbigbang, format) {
-    checker.checkDir("files/entities/")
+    checker.checkDir("files/entities/");
 
-    // There is no pioneer
-    if(checker.checkEmptyDir("files/entities/")){
-        // CREATING PIONEER
-        var entity = pb(fs.readFileSync('node_modules/pathchain/proto/entity.proto'))
+    // Create pioneer only if there's no pioneer yet
+    if (checker.checkEmptyDir("files/entities/")) {
+        const entity = pb(fs.readFileSync('node_modules/pathchain/proto/entity.proto'));
         
-        var register = new Date()
-        register = dt.format(register, dt.compile(format, true));
-
-        var register_moment_hash = moment(register, 0, 0, 0, 0, 0, format)
-
-        var birthday = dt.parse(xbigbang, format, true);
-        birthday = dt.format(birthday, format, true);
+        const register = dt.format(new Date(), dt.compile(format, true));
+        const register_moment_hash = moment(register, 0, 0, 0, 0, 0, format);
 
-        var birthday_moment = moment(birthday, 0, 0, 0, 0, 0, format)
+        const birthday = dt.format(dt.parse(xbigbang, format, true), format, true);
+        const birthday_moment = moment(birthday, 0, 0, 0, 0, 0, format);
 
-        // console.log("PIONEER REGISTER MOMENT: ", register_moment_hash)
-        // console.log("PIONEER BIRTHDAY MOMENT: ", birthday_moment)
+        const pioneer_hash = sha256(`${register_moment_hash}_${birthday_moment}`);
 
-        var pioneer_hash = sha256(register_moment_hash + "_" + birthday_moment);
-
-        var buffer = entity.entity.encode({
-            register: "moments/"+register_moment_hash,
-            ancestor: "entities/"+pioneer_hash, // points to itself as ancestor entity in the chain
-            tag: "entities/"+pioneer_hash,
-        })
+        const buffer = entity.entity.encode({
+            register: `moments/${register_moment_hash}`,
+            ancestor: `entities/${pioneer_hash}`, // points to itself as ancestor
+            tag: `entities/${pioneer_hash}`,
+        });
 
         const the_secret = secret(pioneer_hash, format);
-        console.log("The pioneer secret buffer is: ", the_secret)
+        console.log("The pioneer secret buffer is: ", the_secret);
 
-        // Save as active entity
-        checker.checkDir("files/entities/")
-        fs.writeFileSync("files/entities/" + pioneer_hash, buffer);
+        checker.checkDir("files/entities/");
+        fs.writeFileSync(`files/entities/${pioneer_hash}`, buffer);
 
-        // Save pioneer to look for it later
-        checker.checkDir("files/pioneer/")
-        fs.writeFileSync("files/pioneer/" + pioneer_hash, buffer);
+        checker.checkDir("files/pioneer/");
+        fs.writeFileSync(`files/pioneer/${pioneer_hash}`, buffer);
 
         return pioneer_hash;
-    }
-    // There is a pioneer
-    else{
+    } else {
         return checker.checkFiles('files/pioneer/')[0];
     }
 }
 
-/** entity
- * [Entity Protocol Buffer Creation]
- * 
- * @param {string} xsecret (required)
- * @param {string} format  (optional)
- * 
- * @return {string} secret_hash
+/**
+ * Creates an entity Protocol Buffer
+ * @param {string} xsecret - Secret used for entity creation (required)
+ * @param {string} format - Date format (optional)
+ * @returns {string} entity_hash - Hash of the created entity
  */
 function entity(xsecret, format) {
-
     checker.checkDir("files/entities/");
-    if(checker.checkEmptyDir("files/entities/")){
+    if (checker.checkEmptyDir("files/entities/")) {
         return "A pioneer's secret is needed to create the first entity. There was no pioneer, but here is the one at 'files/pioneer/'" + pioneer();
-    }
-    else{
-        if(checker.isSecretUsed(xsecret) == false){
-            // CREATING entity
-            var entity = pb(fs.readFileSync('node_modules/pathchain/proto/entity.proto'))
+    } else {
+        if (checker.isSecretUsed(xsecret) == false) {
+            const entity = pb(fs.readFileSync('node_modules/pathchain/proto/entity.proto'));
             
-            var register = new Date()
-            register = dt.format(register, dt.compile(format, true));
-
-            var register_moment_hash = moment(register, 0, 0, 0, 0, 0, format)
-            var ancestor_entity_hash = getter.getSecretObj(xsecret).author;
-            // console.log("-> ancestor ENTITY HASH: ", ancestor_entity_hash);
+            const register = dt.format(new Date(), dt.compile(format, true));
+            const register_moment_hash = moment(register, 0, 0, 0, 0, 0, format);
+            const ancestor_entity_hash = getter.getSecretObj(xsecret).author;
 
-            var entity_hash = sha256(register_moment_hash + "_" + ancestor_entity_hash);
+            const entity_hash = sha256(`${register_moment_hash}_${ancestor_entity_hash}`);
 
+            const buffer = entity.entity.encode({
+                register: `moments/${register_moment_hash}`,
+                ancestor: `entities/${ancestor_entity_hash}`,
+                tag: `entities/${entity_hash}`,
+            });
 
-            var buffer = entity.entity.encode({
-                register: "moments/"+register_moment_hash,
-                ancestor: "entities/"+ancestor_entity_hash,
-                tag: "entities/"+entity_hash,
-            })
-
-            var updated_secret = updater.useSecret(xsecret, entity_hash);
+            const updated_secret = updater.useSecret(xsecret, entity_hash);
             console.log("Updated secret: ", updated_secret);
 
-            checker.checkDir("files/entities/") // checking
-            fs.writeFileSync("files/entities/" + entity_hash, buffer);
+            checker.checkDir("files/entities/");
+            fs.writeFileSync(`files/entities/${entity_hash}`, buffer);
 
             return entity_hash;
-        }
-        else{
-            return "Secret has been already used or it was not found"
+        } else {
+            return "Secret has been already used or it was not found";
         }
     }
 }
 
-
-/** node
- * [Node Protocol Buffer Creation]
- * 
- * @param {string} author (optional, default=pioneer_hash)
- * @param {string} file   (optional)
- * @param {string} str    (optional)
- * @param {string} format (required)
- * 
- * @return {string} node_hash
+/**
+ * Creates a node Protocol Buffer
+ * @param {string} text - Node content (required)
+ * @param {string} author - Author of the node (optional, default=pioneer_hash)
+ * @param {string} format - Date format (optional)
+ * @returns {string} node_hash - Hash of the created node
  */
 function node(text, author, format = 'MM DD YYYY HH:mm:SSS [GMT]Z') {
-    var node_pb = pb(fs.readFileSync('node_modules/pathchain/proto/node.proto'))
+    const node_pb = pb(fs.readFileSync('node_modules/pathchain/proto/node.proto'));
 
-    var author_folder = author;
-    if(author == ""){
-        author = author = pioneer(getter.getCurrentDate(), 'MM DD YYYY HH:mm:SSS [GMT]Z');
+    let author_folder = author;
+    if (author == "") {
+        author = pioneer(getter.getCurrentDate(), 'MM DD YYYY HH:mm:SSS [GMT]Z');
         author_folder = "";
-    }else{
-        author_folder = author_folder + '/';
+    } else {
+        author_folder = `${author_folder}/`;
     }
 
-    var register = new Date()
-    register = dt.format(register, dt.compile(format, true));
-
-    var register_moment_hash = moment(register, 0, 0, 0, 0, 0, format)
+    const register = dt.format(new Date(), dt.compile(format, true));
+    const register_moment_hash = moment(register, 0, 0, 0, 0, 0, format);
     
-    var node_hash = sha256(register_moment_hash + "_" + author);
+    const node_hash = sha256(`${register_moment_hash}_${author}`);
     
-    var buffer = node_pb.node.encode({
-        register: "moments/" + register_moment_hash,
-        author: "etities/" + author,
+    const buffer = node_pb.node.encode({
+        register: `moments/${register_moment_hash}`,
+        author: `entities/${author}`,
         text: text,
-        tag: "nodes/" + node_hash
-    })
+        tag: `nodes/${node_hash}`
+    });
 
-    checker.checkDir("files/" + author_folder + "nodes/") // checking
-    fs.writeFileSync("files/" + author_folder + "nodes/" + node_hash, buffer);
+    checker.checkDir(`files/${author_folder}nodes/`);
+    fs.writeFileSync(`files/${author_folder}nodes/${node_hash}`, buffer);
     
     return node_hash;
 }
 
+/**
+ * Creates a path Protocol Buffer
+ * @param {string} text - Path description (optional, default=path_hash)
+ * @param {Array} elements - Array of elements in the path (required)
+ * @param {string} author - Author of the path (optional, default=pioneer_hash)
+ * @param {string} ancestor - Ancestor path (optional, default=path_hash)
+ * @param {string} format - Date format (optional)
+ * @returns {string} path_hash - Hash of the created path
+ */
+function path(text, elements, author, ancestor, format = 'MM DD YYYY HH:mm:SSS [GMT]Z') {
+    const path_pb = pb(fs.readFileSync('node_modules/pathchain/proto/path.proto'));
 
-/** path
-* [Pioneer Protocol Buffer Creation]
-* 
-* @param {string} author (optional, default=pioneer_hash)
-* @param {string} text   (optional, default=path_hash)
-* @param {string} head   (required)
-* @param {string} ancestor (optional, default=path_hash)
-* @param {string} format (required)
-* 
-* @return {string} path_hash
-*/
-function path(text, head, author, ancestor, format = 'MM DD YYYY HH:mm:SSS [GMT]Z') {
-   var path_pb = pb(fs.readFileSync('node_modules/pathchain/proto/path.proto'))
-
-   var author_folder = author;
-   if(author == ""){
-        author = author = pioneer(getter.getCurrentDate(), 'MM DD YYYY HH:mm:SSS [GMT]Z');
+    let author_folder = author;
+    if (author == "") {
+        author = pioneer(getter.getCurrentDate(), 'MM DD YYYY HH:mm:SSS [GMT]Z');
         author_folder = "";
-   }else{
-        author_folder = author_folder + '/';
-   }
-
-   var register = new Date()
-   register = dt.format(register, dt.compile(format, true));
+    } else {
+        author_folder = `${author_folder}/`;
+    }
 
-   var register_moment_hash = moment(register, 0, 0, 0, 0, 0, format)
+    const register = dt.format(new Date(), dt.compile(format, true));
+    const register_moment_hash = moment(register, 0, 0, 0, 0, 0, format);
 
-   var path_hash = sha256(register_moment_hash + "_" + author);
+    const path_hash = sha256(`${register_moment_hash}_${author}`);
    
-   if(text == ""){ text = path_hash; }
-   if(head == ""){ return "Head node_link is required to create a path!" }
-   if(ancestor == ""){ ancestor = path_hash; }
-
-   var buffer = path_pb.path.encode({
-       register: "moments/"+register_moment_hash,
-       author: author,
-       text: text,
-       head: "links/" + head,
-       ancestor: author_folder + "paths/" + ancestor,
-       tag: author_folder + "paths/" + path_hash,
-   })
-
-   checker.checkDir("files/" + author_folder + "paths/") // checking
-   fs.writeFileSync("files/" + author_folder + "paths/" + path_hash, buffer);
+    if (text == "") { text = path_hash; }
+ 
+    let prev_link = "";
+    // Building target chain
+    for (let i = 0; i < elements.length; i++) {
+        const current_link = link(elements[i], "", "", author, "");
+        if (i > 0) {
+            updater.setLinkNext(prev_link, current_link);
+            updater.setPrevLink(current_link, prev_link);
+        }
+        prev_link = current_link;
+    }
+
+    if (ancestor == "") { ancestor = path_hash; }
+
+    const buffer = path_pb.path.encode({
+        register: `moments/${register_moment_hash}`,
+        author: author,
+        text: text,
+        head: `links/${prev_link}`,
+        ancestor: `${author_folder}paths/${ancestor}`,
+        tag: `${author_folder}paths/${path_hash}`,
+    });
+
+    checker.checkDir(`files/${author_folder}paths/`);
+    fs.writeFileSync(`files/${author_folder}paths/${path_hash}`, buffer);
    
-   return path_hash;
+    return path_hash;
 }
 
-
-/** label
- * [Label Protocol Buffer Creation]
- * 
- * @param {string} author (optional, default=pioneer_hash)
- * @param {string} file   (optional)
- * @param {string} str    (optional)
- * @param {string} format (required)
- * 
- * @return {string} label_hash
+/**
+ * Creates a label Protocol Buffer
+ * @param {string} text - Label text (required)
+ * @param {string} author - Author of the label (optional, default=pioneer_hash)
+ * @param {string} ancestor - Ancestor label (optional, default=label_hash)
+ * @param {string} format - Date format (optional)
+ * @returns {string} label_hash - Hash of the created label
  */
 function label(text, author, ancestor, format = 'MM DD YYYY HH:mm:SSS [GMT]Z') {
-    var label_pb = pb(fs.readFileSync('node_modules/pathchain/proto/label.proto'))
+    const label_pb = pb(fs.readFileSync('node_modules/pathchain/proto/label.proto'));
 
-    var author_folder = author; 
-    if(author == ""){
-        author = author = pioneer(getter.getCurrentDate(), 'MM DD YYYY HH:mm:SSS [GMT]Z');
+    let author_folder = author; 
+    if (author == "") {
+        author = pioneer(getter.getCurrentDate(), 'MM DD YYYY HH:mm:SSS [GMT]Z');
         author_folder = "";
-    }else{
-        author_folder = author_folder + '/';
+    } else {
+        author_folder = `${author_folder}/`;
     }
 
-    var register = new Date()
-    register = dt.format(register, dt.compile(format, true));
-
-    var register_moment_hash = moment(register, 0, 0, 0, 0, 0, format)
+    const register = dt.format(new Date(), dt.compile(format, true));
+    const register_moment_hash = moment(register, 0, 0, 0, 0, 0, format);
     
-    var label_hash = sha256(register_moment_hash + "_" + author);
+    const label_hash = sha256(`${register_moment_hash}_${author}`);
 
-    if(ancestor == ""){
+    if (ancestor == "") {
         ancestor = label_hash;        
     }
     
-    var buffer = label_pb.label.encode({
-        register: "moments/" + register_moment_hash,
-        author: "etities/" + author,
+    const buffer = label_pb.label.encode({
+        register: `moments/${register_moment_hash}`,
+        author: `entities/${author}`,
         text: text,
-        ancestor: author_folder + "labels/" + ancestor,
-        tag: author_folder + "labels/" + label_hash
-    })
+        ancestor: `${author_folder}labels/${ancestor}`,
+        tag: `${author_folder}labels/${label_hash}`
+    });
 
-    checker.checkDir("files/" + author_folder + "labels/") // checking
-    fs.writeFileSync("files/" + author_folder + "labels/" + label_hash, buffer);
+    checker.checkDir(`files/${author_folder}labels/`);
+    fs.writeFileSync(`files/${author_folder}labels/${label_hash}`, buffer);
     
     return label_hash;
 }
 
-
-/** link
- * [Link Protocol Buffer Creation]
- *
- * @param {string} target   (optional)
- * @param {string} prev     (optional)
- * @param {string} next     (optional) 
- * @param {string} author   (optional, default=pioneer_hash)
- * @param {string} ancestor (optional)
- * @param {string} format   (required)
- * 
- * @return {string} link_hash
+/**
+ * Creates a link Protocol Buffer
+ * @param {string} target - Target of the link (required)
+ * @param {string} prev - Previous link in chain (optional, default=link_hash)
+ * @param {string} next - Next link in chain (optional, default=link_hash)
+ * @param {string} author - Author of the link (optional, default=pioneer_hash)
+ * @param {string} ancestor - Ancestor link (optional, default=link_hash)
+ * @param {string} format - Date format (optional)
+ * @returns {string} link_hash - Hash of the created link
  */
 function link(target, prev, next, author, ancestor, format = 'MM DD YYYY HH:mm:SSS [GMT]Z') {
-    var link_pb = pb(fs.readFileSync('node_modules/pathchain/proto/link.proto'))
+    // Load the link protocol buffer definition
+    const link_pb = pb(fs.readFileSync('node_modules/pathchain/proto/link.proto'));
 
-    if(target == "") return "The link must link something. Target can't be null.";
+    // Validate target
+    if (target === "") {
+        return "The link must link something. Target can't be null.";
+    }
 
-    var author_folder = author; 
-    if(author == ""){
-        author = author = pioneer(getter.getCurrentDate(), 'MM DD YYYY HH:mm:SSS [GMT]Z');
+    // Handle author and author folder
+    let author_folder = author; 
+    if (author === "") {
+        author = pioneer(getter.getCurrentDate(), 'MM DD YYYY HH:mm:SSS [GMT]Z');
         author_folder = "";
-    }else{
-        author_folder = author_folder + '/';
+    } else {
+        author_folder = `${author_folder}/`;
     }
 
-    var register = new Date()
-    register = dt.format(register, dt.compile(format, true));
-
-    var register_moment_hash = moment(register, 0, 0, 0, 0, 0, format)
+    // Create a moment for this link
+    const register = dt.format(new Date(), dt.compile(format, true));
+    const register_moment_hash = moment(register, 0, 0, 0, 0, 0, format);
     
-    var link_hash = sha256(register_moment_hash + "_" + author + "_" + prev + "_" + next);
+    // Generate a unique hash for this link
+    const link_hash = sha256(`${register_moment_hash}_${author}_${prev}_${next}`);
 
-    if(ancestor == ""){
-        ancestor = link_hash;        
-    }
-    if(prev == ""){
-        prev = link_hash;        
-    }
-    if(next == ""){
-        next = link_hash;        
-    }
+    // Set default values if not provided
+    if (ancestor === "") { ancestor = link_hash; }
+    if (prev === "") { prev = link_hash; }
+    if (next === "") { next = link_hash; }
     
-    // Find the target to figure out its nature (node, path or label)
-    if(checker.checkFile("files/" + author_folder + "nodes/" + target) == true){
-        target = 'nodes/' + target;
-        console.log("Target is a node")
-    }
-    if(checker.checkFile("files/" + author_folder + "paths/" + target) == true){
-        target = 'paths/' + target;
-        console.log("Target is a path")
+    // Determine the nature of the target (node, path, or label)
+    let target_type = "";
+    if (checker.checkFile(`files/${author_folder}nodes/${target}`)) {
+        target_type = "nodes";
+    } else if (checker.checkFile(`files/${author_folder}paths/${target}`)) {
+        target_type = "paths";
+    } else if (checker.checkFile(`files/${author_folder}labels/${target}`)) {
+        target_type = "labels";
     }
-    if(checker.checkFile("files/" + author_folder + "labels/" + target) == true){
-        target = 'labels/' + target;
-        console.log("Target is a label")
-    }
-
     
+    if (target_type) {
+        target = `${target_type}/${target}`;
+        console.log(`Target is a ${target_type.slice(0, -1)}`);
+    } else {
+        console.log("Warning: Target type not recognized");
+    }
 
-    var buffer = link_pb.link.encode({
-        register: "moments/" + register_moment_hash,
-        author: "etities/" + author,
-        prev: "links/" + prev,
-        next: "links/" + next,
+    // Encode the link data into a protocol buffer
+    const buffer = link_pb.link.encode({
+        register: `moments/${register_moment_hash}`,
+        author: `entities/${author}`,
+        prev: `links/${prev}`,
+        next: `links/${next}`,
         target: target,
-        ancestor: author_folder + "links/" + ancestor,
-        tag: author_folder + "links/" + link_hash
-    })
+        ancestor: `${author_folder}links/${ancestor}`,
+        tag: `${author_folder}links/${link_hash}`
+    });
 
-    checker.checkDir("files/" + author_folder + "links/") // checking
-    fs.writeFileSync("files/" + author_folder + "links/" + link_hash, buffer);
+    // Ensure the directory exists and write the link buffer to a file
+    checker.checkDir(`files/${author_folder}links/`);
+    fs.writeFileSync(`files/${author_folder}links/${link_hash}`, buffer);
     
     return link_hash;
 }
 
-
-module.exports = { moment, pioneer, secret, entity, node, path, label, link }
+module.exports = { moment, pioneer, secret, entity, node, path, label, link };

package/package.json

@@ -34,5 +34,5 @@
   "deprecated": false,
   "description": "![image](https://user-images.githubusercontent.com/104391124/282268780-cbbc1ee6-8d97-4d80-b896-66ae3eb723dd.png)",
   "name": "pathchain",
-  "version": "1.0.60"
+  "version": "1.1.0"
 }

package/updater.js

@@ -43,4 +43,98 @@ function useSecret(xsecret, xauthor = "") {
     return secret_obj;
 }
 
-module.exports = { useSecret }
+
+/** setLinkNext
+ * [Function that updates the 'next' pointer of a link]
+ * 
+ * @param {string} xlink
+ * @param {string} xnextlink
+ * 
+ * @return {string} xlink
+ */
+function setLinkNext(xlink = "", xnextlink = "") {
+
+    // LOADING PB
+    var link_pb = pb(fs.readFileSync('node_modules/pathchain/proto/link.proto'))
+    
+    // EXCEPTIONS FOR NOT FOUND LINKS
+    var fileContents;
+
+    // NOT FOUND EXCEPTION FOR 'xlink'
+    try {
+        fileContents = fs.readFileSync("files/links/" + xlink);
+    } catch (err) {
+        if (err.code === 'ENOENT') {
+            return "Link '" + xlink + "' not found";
+        } else {
+            throw err;
+        }
+    }
+
+    // NOT FOUND EXCEPTION FOR 'xnextlink'
+    try {
+        fileContents = fs.readFileSync("files/links/" + xnextlink);
+    } catch (err) {
+        if (err.code === 'ENOENT') {
+            return "Link '" + xnextlink + "' not found";
+        } else {
+            throw err;
+        }
+    }
+
+    // DECODING LINK
+    var link_enc = fileContents
+    var link_obj = link_pb.link.decode(link_enc)
+
+    link_obj.next = xnextlink;
+    return link_obj;
+}
+
+
+/** setLinkPrev
+ * [Function that updates the 'previous' pointer of a link]
+ * 
+ * @param {string} xlink
+ * @param {string} xprevlink
+ * 
+ * @return {string} xlink
+ */
+function setLinkPrev(xlink = "", xprevlink = "") {
+
+    // LOADING PB
+    var link_pb = pb(fs.readFileSync('node_modules/pathchain/proto/link.proto'))
+    
+    // EXCEPTIONS FOR NOT FOUND LINKS
+    var fileContents;
+
+    // NOT FOUND EXCEPTION FOR 'xlink'
+    try {
+        fileContents = fs.readFileSync("files/links/" + xlink);
+    } catch (err) {
+        if (err.code === 'ENOENT') {
+            return "Link '" + xlink + "' not found";
+        } else {
+            throw err;
+        }
+    }
+
+    // NOT FOUND EXCEPTION FOR 'xprevlink'
+    try {
+        fileContents = fs.readFileSync("files/links/" + xprevlink);
+    } catch (err) {
+        if (err.code === 'ENOENT') {
+            return "Link '" + xprevlink + "' not found";
+        } else {
+            throw err;
+        }
+    }
+
+    // DECODING LINK
+    var link_enc = fileContents
+    var link_obj = link_pb.link.decode(link_enc)
+
+    link_obj.prev = xprevlink;
+    return link_obj;
+}
+
+module.exports = { useSecret, setLinkNext, setLinkPrev }