nv-file-basic/index.js

nv-file-basic ============== - simple async wrap of node fs-module - add some symbol-link functions

const path = require("path");

const fs   = require("fs");
const util = require("util");
const _promisify  = util.promisify;

const pbsc = require("nv-path-basic");

const _readdir    = _promisify(fs.readdir);
const _readlink   = _promisify(fs.readlink);
const _lstat      = _promisify(fs.lstat);
const _exist      = _promisify(fs.exists);

const CONSTS = require("nv-file-const");

const exist = async (p) => {
    let cond = await _exist(p);
    if(cond) {
        return(true)
    } else {
        try {
           await _lstat(p);
           return(true) 
        } catch(err) {
            return(false)
        }
    }
}

const is_slink = async (p) => {
    let rslt = await _lstat(p);
    return(rslt.isSymbolicLink())
}


const is_file = async (p) => {
    let rslt = await _lstat(p);
    return(rslt.isFile())
}

const is_dir = async (p) => {
    let rslt = await _lstat(p);
    return(rslt.isDirectory())
}

const is_blk_dev = async (p) => {
    let rslt = await _lstat(p);
    return(rslt.isBlockDevice())
}

const is_char_dev = async (p) => {
    let rslt = await _lstat(p);
    return(rslt.isCharacterDevice())
}

const is_fifo = async (p) => {
    let rslt = await _lstat(p);
    return(rslt.isFIFO())
}

const is_sock = async (p) => {
    let rslt = await _lstat(p);
    return(rslt.isSocket())
}

const _get_tname_with_stat = (stat) => {
     if(stat.isSymbolicLink()) {
         return('slink')
     } else if(stat.isFile()) {
         return('file')
     } else if(stat.isDirectory()) {
         return('dir')
     } else if(stat.isBlockDevice()) {
         return('blk_dev')
     } else if(stat.isCharacterDevice()) {
         return('char_dev')
     } else if(stat.isFIFO()) {
         return('fifo')
     } else if(stat.isSocket()) {
         return('sock')
     } else {
         return('noexist')
     }
}


const get_tname = async (p) => {
     let cond =await _exist(p);
     if(cond) {
         let stat = await _lstat(p);
         return(_get_tname_with_stat(stat))
     } else {
         return('noexist')
     }
}



////
const _get_children_with_stat = async (p,stat) => {
    let cond = stat.isDirectory();
    if(cond) {
        let arr = await _readdir(p);
        arr = arr.map(r=>path.join(p,r));
        return(arr)
    } else {
        return([])
    }
}

const get_children = async (p) => {
     p = path.resolve(p);
     let cond = await _exist(p);
     if(cond) {
         let stat = await _lstat(p);
         return(await _get_children_with_stat(p,stat))
     } else {
         return([])
     }
}

const _is_leaf_with_stat = async (p,stat) => {
    let cond = stat.isDirectory();
    if(cond) {
        let arr = await _readdir(p);
        return(arr.length ===0)
    } else {
        return(_t)
    }
}

const is_leaf = async(p) => {
     p = path.resolve(p);
     let cond = await _exist(p);
     if(cond) {
         let stat = await _lstat(p);
         return(await _is_leaf_with_stat(p,stat))
     } else {
         return(_t)
     }
}


////

const _readlink_without_resolve = async(p) => {
    let np = await _readlink(p);
    return(pbsc.creat_sib_after_resolve(p,np))
}

const readlink   = async (p)=> {
    p = path.resolve(p);
    return(await _readlink_without_resolve(p))
}


const readlink_r = async (p) => {
    p = path.resolve(p);
    let rslt = await _lstat(p);
    while(rslt.isSymbolicLink()) {
        p = await _readlink_without_resolve(p);
        try {
            rslt = await _lstat(p);
        } catch(err) {
            break
        }
    }
    return(p)
}



const is_valid_slink = async (p) => {
    let rslt = await _lstat(p);
    let cond = rslt.isSymbolicLink();
    if(cond) {
        let np = await _readlink(p);
        let r = await exist(np);
        return(r)
    } else {
        return(false)
    }
}

const is_invalid_slink = async (p) => {
    let rslt = await _lstat(p);
    let cond = rslt.isSymbolicLink();
    if(cond) {
        let np = await _readlink(p);
        let r = await exist(np);
        return(!r)
    } else {
        return(false)
    }
}


const  is_valid_slink_r = async (p) => {
    let cond = await _exist(p); 
    if(cond) {
        return(await is_slink(p))
    } else {
        return(false)
    }
}


const  is_invalid_slink_r = async (p) => {
    let cond = await is_slink(p)
    if(cond) {
        let rslt = !(await _exist(r))
        return(rslt)
    } else {
        return(false)
    }
}


const size = async (p) => {
   let stat = await _lstat(p);
   return(stat.size) 
}


class Permission {
    owner_can_read=false;
    owner_can_write=false;
    owner_can_exec=false;
    group_can_read=false;
    group_can_write=false;
    group_can_exec=false;
    other_can_read=false;
    other_can_write=false;
    other_can_exec=false
}


const _permission_with_stat = (stat) => {
    let mode = stat.mode;
    mode = mode & 0b111111111;
    let d = new Permission();
    for(let k in CONSTS.PNAMES) {
        d[k] = Boolean(mode & CONSTS.pname_to_num(k) )
    }
    return(d)
}

const permission = async (p)=> {
    let stat = await _lstat(p);
    return(_permission_with_stat(stat))
}

const STAT_CNL = [
  'dev',     'mode',
  'nlink',   'uid',
  'gid',     'rdev',
  'blksize', 'ino',
  'size',    'blocks',
  'atime',   'mtime',
  'ctime',   'birthtime'
]

const STAT_DB_SRCH_TYPE = [
  'int8',     'int8',
  'int8',   'int8',
  'int8',     'int8',
  'int8', 'int8',
  'int8',    'int8',
  'mts',   'mts',
  'mts',   'mts'
]


class Stat {
      dev =0;
      mode =0;
      nlink=0;
      uid=0;
      gid=0;
      rdev=0;
      blksize=0;
      ino=0;
      size=0;
      blocks=0;
      atimeMs=0.1;
      mtimeMs=0.1;
      ctimeMs=0.1;
      birthtimeMs=0.1;
      atime=new Date();
      mtime=new Date();
      ctime=new Date();
      birthtime=new Date();
      permission=new Permission()
      type ='noexist'
      ////
      to_db() {
          let D = {}
          for(let colname of STAT_CNL) {
              D[colname] = this[colname]
          }
          D.atime = parseInt(this.atimeMs)
          D.mtime = parseInt(this.mtimeMs)
          D.ctime = parseInt(this.ctimeMs)
          D.birthtime = parseInt(this.birthtimeMs)
          D.permission = JSON.stringify(this.permission);
          return(D)
      }
}


const lstat = async (p)=> {
    let stat = await _lstat(p);
    let d = new Stat();
    Object.assign(d,stat);
    d.permission = _permission_with_stat(stat);
    d.type = _get_tname_with_stat(stat);
    return(d)
}

const OD = Object.defineProperty;
const {open} = require("fs/promises");
const kvlist2d = (kl,vl)=> {
    let d = {};
    for(let i=0;i<kl.length;++i) {
        d[kl[i]] = vl[i];
    }
    return(d)
}



let FH_SYMS ;

const _FH_SYMS = async() => {
	let fd = await open(__filename);
    let syms = Object.getOwnPropertySymbols(fd);
    let ks = syms.map(sym=>sym.description);
    let d = kvlist2d(ks,syms);
	FH_SYMS = d;
	await fd.close();;
    return(d)
}

_FH_SYMS();




module.exports = {
    CONSTS,
    ////
    _readdir,
    _readlink,
    _lstat,
    _exist,
    ////
    size,
    ////
    exist,
    exist_r:_exist,
    ////
    is_slink,
    is_file,
    is_dir,
    is_char_dev,
    is_blk_dev,
    is_fifo,
    is_sock,
    ////
    _get_tname_with_stat,
    get_tname,
    ////
    _get_children_with_stat,
    get_children,
    ////
    _readlink_without_resolve,
    readlink,
    readlink_r,
    is_valid_slink,
    is_invalid_slink,
    is_valid_slink_r,
    is_invalid_slink_r,
    ////
    _is_leaf_with_stat,
    is_leaf,
    ////
    Permission,
    _permission_with_stat,
    permission,
    ////
    STAT_CNL,
    STAT_DB_SRCH_TYPE,
    Stat,
    lstat,
}

OD(module.exports,'FH_SYMS_',{get:function(){
    if(FH_SYMS!==undefined) {
        return(FH_SYMS)
    } else {
        return(_FH_SYMS());
    }
}});