@tremho/mist-lift 1.0.2-pre-release.4 → 1.0.2-pre-release.5

package/src/lib/LiftVersion.ts

@@ -1,95 +1,87 @@
 
 import * as path from 'path'
 import * as fs from 'fs'
-import {resolvePaths} from "./pathResolve";
+import { resolvePaths } from './pathResolve'
 
-export class VersionInfo
-{
-    public major:number = 0
-    public minor:number = 0
-    public revision:number = 0
-    public suffix:string = "";
+export class VersionInfo {
+  public major: number = 0
+  public minor: number = 0
+  public revision: number = 0
+  public suffix: string = ''
 
-    constructor(vstr:string) {
-        this.parse(vstr);
-    }
+  constructor (vstr: string) {
+    this.parse(vstr)
+  }
 
-    public toString = () => {
-        return `${this.major}.${this.minor}.${this.revision}`+(this.suffix? "-"+this.suffix : "")
-    }
-    public parse = (vstr:string) => {
-        let sn = vstr.indexOf('-');
-        let suffix = ""
-        if(sn !== -1) {
-            suffix = vstr.substring(sn+1);
-            vstr = vstr.substring(0,sn);
-        }
-        let parts = vstr.split('.');
-        while(parts.length < 3) parts.push("0");
-        this.major = parseInt(parts[0])
-        this.minor = parseInt(parts[1]);
-        this.revision = parseInt(parts[2]);
-        if(!isFinite(this.major)) this.major = 0;
-        if(!isFinite(this.minor)) this.minor = 0;
-        if(!isFinite(this.revision)) this.revision = 0;
-        this.suffix = suffix;
-    }
-    public equals(other: VersionInfo | string): boolean
-    {
-        // Note: not really a valid SemVer comparison
-        if(typeof other === 'string') other = new VersionInfo(other);
-        return this.major === other.major
-           &&  this.minor === other.minor
-           &&  this.revision === other.revision
-    }
-    public isGreaterThan(other:VersionInfo | string): boolean
-    {
-        // Note: not really a valid SemVer comparison
-        if(typeof other === 'string') other = new VersionInfo(other);
-        if(this.major > other.major) return true;
-        if(this.major < other.major) return false;
-        if(this.minor > other.minor) return true;
-        if(this.minor < other.minor) return false;
-        return (this.revision > other.revision);
+  public toString = (): string => {
+    let sfx = ''
+    if (this.suffix !== '') sfx = '-' + this.suffix
+    return `${this.major}.${this.minor}.${this.revision}${sfx}`
+  }
+
+  public parse = (vstr: string): VersionInfo => {
+    const sn = vstr.indexOf('-')
+    let suffix = ''
+    if (sn !== -1) {
+      suffix = vstr.substring(sn + 1)
+      vstr = vstr.substring(0, sn)
     }
+    const parts = vstr.split('.')
+    while (parts.length < 3) parts.push('0')
+    this.major = parseInt(parts[0])
+    this.minor = parseInt(parts[1])
+    this.revision = parseInt(parts[2])
+    if (!isFinite(this.major)) this.major = 0
+    if (!isFinite(this.minor)) this.minor = 0
+    if (!isFinite(this.revision)) this.revision = 0
+    this.suffix = suffix
+    return this
+  }
+
+  public equals (other: VersionInfo | string): boolean {
+    // Note: not really a valid SemVer comparison
+    if (typeof other === 'string') other = new VersionInfo(other)
+    return this.major === other.major &&
+           this.minor === other.minor &&
+           this.revision === other.revision
+  }
+
+  public isGreaterThan (other: VersionInfo | string): boolean {
+    // Note: not really a valid SemVer comparison
+    if (typeof other === 'string') other = new VersionInfo(other)
+    if (this.major > other.major) return true
+    if (this.major < other.major) return false
+    if (this.minor > other.minor) return true
+    if (this.minor < other.minor) return false
+    return (this.revision > other.revision)
+  }
 }
 
 // read version from Lift's package.json
-export function getLiftVersion()
-{
-    let pkg = path.join(__dirname, '..', '..', 'package.json');
-    return readPackageVersion(pkg);
-
+export function getLiftVersion (): VersionInfo {
+  const pkg = path.join(__dirname, '..', '..', 'package.json')
+  return readPackageVersion(pkg)
 }
 // read version from project's package.json
-export function getProjectVersion()
-{
-    const projectPaths = resolvePaths();
-    return readPackageVersion(projectPaths.packagePath)
-
+export function getProjectVersion (): VersionInfo {
+  const projectPaths = resolvePaths()
+  return readPackageVersion(projectPaths.packagePath)
 }
 
-export function getProjectName()
-{
-    const projectPaths = resolvePaths();
-    let pkgJson:{name?:string} = {}
-    try {
-        pkgJson = JSON.parse(fs.readFileSync(projectPaths.packagePath).toString())
-    }
-    catch(e) {}
-    return pkgJson.name;
+export function getProjectName (): string {
+  const projectPaths = resolvePaths()
+  let pkgJson: { name?: string } = {}
+  try {
+    pkgJson = JSON.parse(fs.readFileSync(projectPaths.packagePath).toString())
+  } catch (e) {}
+  return pkgJson.name ?? ''
 }
 
-function readPackageVersion(pkgPath:string):VersionInfo
-{
-    let pkgJson:{version?:string} = {}
-    try {
-        pkgJson = JSON.parse(fs.readFileSync(pkgPath).toString())
-    }
-    catch(e) {}
-
-    return new VersionInfo(pkgJson.version ?? "")
+function readPackageVersion (pkgPath: string): VersionInfo {
+  let pkgJson: { version?: string } = {}
+  try {
+    pkgJson = JSON.parse(fs.readFileSync(pkgPath).toString())
+  } catch (e) {}
 
+  return new VersionInfo(pkgJson.version ?? '')
 }
-
-

package/src/lib/Tests/fileCompare.test.ts

@@ -1,34 +1,35 @@
 
-import Tap from "tap"
+/* eslint @typescript-eslint/no-floating-promises: "off" */
 
-import * as path from 'path'
-import {isNewer, isNewerFile} from "../fileCompare";
+import Tap from 'tap'
 
-function test(t:any) {
+import * as path from 'path'
+import { isNewerFile } from '../fileCompare'
 
+function test (t: any): void {
 // ./dir1/file.1 551 < ./dir2/file.1 552
-// ./dir1/file.2 553 > ./dir2/file.1 552
-// ./dir1  553 > ./dir2 552
-// .dir1 (.1) 552 < ./dir2 552
-
-    const dir1 = path.join(__dirname, "dir1");
-    const dir2 = path.join(__dirname, "dir2");
-    const dir1File1 = path.join(dir1, "file.1");
-    const dir1File2 = path.join(dir1, "file.2");
-    const dir2File1 = path.join(dir2, "file.1");
-
-    let newer = isNewerFile(dir1File1, dir2File1)
-    t.equal(newer, false, "./dir1/file.1 < ./dir2/file.1")
-    newer = isNewerFile(dir1File2, dir2File1)
-    t.equal(newer, true, "./dir1/file.2 > ./dir2/file.1")
-    newer = isNewerFile(dir1, dir2);
-    t.ok(newer, "dir1 > dir2");
-    newer = isNewerFile(dir1, dir2, ".1");
-    t.ok(!newer, "./dir1 (.1) < ./dir2")
-
-
-    t.end()
+  // ./dir1/file.2 553 > ./dir2/file.1 552
+  // ./dir1  553 > ./dir2 552
+  // .dir1 (.1) 552 < ./dir2 552
+
+  const dir1 = path.join(__dirname, 'dir1')
+  const dir2 = path.join(__dirname, 'dir2')
+  const dir1File1 = path.join(dir1, 'file.1')
+  const dir1File2 = path.join(dir1, 'file.2')
+  const dir2File1 = path.join(dir2, 'file.1')
+
+  let newer = isNewerFile(dir1File1, dir2File1)
+  t.equal(newer, false, './dir1/file.1 < ./dir2/file.1')
+  newer = isNewerFile(dir1File2, dir2File1)
+  t.equal(newer, true, './dir1/file.2 > ./dir2/file.1')
+  newer = isNewerFile(dir1, dir2)
+  t.ok(newer, 'dir1 > dir2')
+  newer = isNewerFile(dir1, dir2, '.1')
+  t.ok(!newer, './dir1 (.1) < ./dir2')
+
+  t.end()
 }
+
 Tap.test('IsNewer', t => {
-    test(t)
+  test(t)
 })

package/src/lib/askQuestion.ts

@@ -1,18 +1,17 @@
 /** handles interaction for asking a question */
 
-import * as ac from "ansi-colors"
-const readlineSync = require("readline-sync")
+/* eslint @typescript-eslint/no-var-requires: "off" */
+import * as ac from 'ansi-colors'
+const readlineSync = require('readline-sync')
 
-export function ask(
-    desc:string, // describes the context
-    query:string,  // asks the actual question
-    def:string // default answer
+export function ask (
+  desc: string, // describes the context
+  query: string, // asks the actual question
+  def: string // default answer
 
-) :string // answer provided
-{
-    console.log(ac.dim.blue.italic(desc))
-    let answer = readlineSync.question(ac.bold.green(query) + ac.dim.grey(` [${def}] `)+ '? ')
-    if(!answer) answer = def
-    return answer
+): string { // answer provided
+  console.log(ac.dim.blue.italic(desc))
+  let answer = readlineSync.question(ac.bold.green(query) + ac.dim.grey(` [${def}] `) + '? ')
+  if (answer === '') answer = def
+  return answer
 }
-

package/src/lib/executeCommand.ts

@@ -1,38 +1,45 @@
 
-import {exec} from 'child_process'
-import * as path from 'path'
+import { exec } from 'child_process'
 
-export function executeCommand(cmd:string, args:any[],  cwd = '', consolePass = false, env:any = {}):Promise<any> {
-    const out = {
-        stdStr: '',
-        errStr: '',
-        retcode: 0
+interface StringObject {
+  toString: () => string
+}
+
+export async function executeCommand (cmd: string, args: any[], cwd = '', consolePass = false, env: any = {}): Promise<any> {
+  const out = {
+    stdStr: '',
+    errStr: '',
+    retcode: 0
+  }
+  return await new Promise(resolve => {
+    const cmdstr = cmd + ' ' + args.join(' ')
+    // console.log('executing ', cmdstr, 'at', cwd)
+    const opts = {
+      cwd,
+      env: Object.assign(env, process.env)
+    }
+    const proc = exec(cmdstr, opts)
+    if (proc.stdout != null) {
+      proc.stdout.on('data', (data: StringObject) => {
+        out.stdStr += data.toString()
+        if (consolePass) process.stdout.write(data.toString())
+      })
     }
-    return  new Promise(resolve => {
-        let cmdstr = cmd + ' ' + args.join(' ')
-        // console.log('executing ', cmdstr, 'at', cwd)
-        const opts = {
-            cwd:cwd,
-            env: Object.assign(env, process.env)
-        }
-        const proc = exec(cmdstr, opts)
-        if(proc.stdout) proc.stdout.on('data', data => {
-            out.stdStr += data.toString()
-            if(consolePass) process.stdout.write(data.toString())
-        })
-        if(proc.stderr) proc.stderr.on('data', data => {
-            out.errStr += data.toString()
-            if(consolePass) process.stdout.write(data.toString())
-        })
-        proc.on('error', error => {
-            console.error(error)
-            if(!out.errStr) out.errStr = error.message
-            out.retcode = -1
-            resolve(out)
-        })
-        proc.on('close', code => {
-            out.retcode = code === null ? -1 : code
-            resolve(out)
-        })
+    if (proc.stderr != null) {
+      proc.stderr.on('data', (data: StringObject) => {
+        out.errStr += data.toString()
+        if (consolePass) process.stdout.write(data.toString())
+      })
+    }
+    proc.on('error', error => {
+      console.error(error)
+      if (out.errStr === '') out.errStr = error.message
+      out.retcode = -1
+      resolve(out)
+    })
+    proc.on('close', code => {
+      out.retcode = code === null ? -1 : code
+      resolve(out)
     })
+  })
 }

package/src/lib/fileCompare.ts

@@ -1,46 +1,55 @@
-import path from "path";
-import fs from "fs";
-import {recurseDirectory} from "./DirectoryUtils";
+import path from 'path'
+import fs from 'fs'
+import { recurseDirectory } from './DirectoryUtils'
 
 // true if filepath > mapped file in outDir (i.e. .ts > .js)
-export function isNewer(filepath:string, outDir:string, mappingObj:any = {".ts": ".js"})
-{
-    let basename = path.basename(filepath);
-    let ext = path.extname(filepath)
-    basename = basename.substring(0, basename.lastIndexOf(ext));
-    let newExt = "";
+export function isNewer (
+  filepath: string,
+  outDir: string,
+  mappingObj: any = { '.ts': '.js' }
+): boolean {
+  let basename = path.basename(filepath)
+  const ext = path.extname(filepath)
+  basename = basename.substring(0, basename.lastIndexOf(ext))
+  let newExt = ''
 
-    if(mappingObj[ext]) newExt = mappingObj[ext];
+  if (mappingObj[ext] !== undefined) newExt = mappingObj[ext]
 
-    let outfile = path.join(outDir, basename+newExt);
-    return isNewerFile(filepath, outfile);
+  const outfile = path.join(outDir, basename + newExt)
+  return isNewerFile(filepath, outfile)
 }
 
 // true if filepath is newer than destpath
-export function isNewerFile(filepath:string, destpath:string, srcFilter:string = "", dstFilter:string = "")
-{
-    const sstat = fs.statSync(filepath);
-    const srcTime = sstat.isDirectory() ? latestInDirectory(filepath, srcFilter) : fs.statSync(filepath).mtime;
-    let destTime = new Date(0);
-    if(fs.existsSync((destpath))) {
-        const dstat = fs.statSync(destpath);
-        destTime = dstat.isDirectory() ? latestInDirectory(destpath, dstFilter) : fs.statSync(destpath).mtime;
-    }
-    return (srcTime >= destTime)
+export function isNewerFile (
+  filepath: string,
+  destpath: string,
+  srcFilter: string = '',
+  dstFilter: string = ''
+): boolean {
+  const sstat = fs.statSync(filepath)
+  const srcTime = sstat.isDirectory() ? latestInDirectory(filepath, srcFilter) : fs.statSync(filepath).mtime
+  let destTime = new Date(0)
+  if (fs.existsSync((destpath))) {
+    const dstat = fs.statSync(destpath)
+    destTime = dstat.isDirectory() ? latestInDirectory(destpath, dstFilter) : fs.statSync(destpath).mtime
+  }
+  return (srcTime >= destTime)
 }
-function latestInDirectory(dirPath:string, extFilter:string = "")
-{
-    let newestTime = new Date(0);
-    recurseDirectory(dirPath, (filepath, stats) => {
-        if(stats.isFile()) {
-            const ext = path.extname(filepath);
-            if(!extFilter || ext === extFilter) {
-                if(stats.mtime > newestTime) {
-                    newestTime = stats.mtime
-                }
-            }
+function latestInDirectory (
+  dirPath: string,
+  extFilter: string = ''
+): Date {
+  let newestTime = new Date(0)
+  recurseDirectory(dirPath, (filepath, stats) => {
+    if (stats.isFile()) {
+      const ext = path.extname(filepath)
+      if ((extFilter ?? '') === '' || ext === extFilter) {
+        if (stats.mtime > newestTime) {
+          newestTime = stats.mtime
         }
-    })
-    return newestTime;
-
-}
+      }
+    }
+    return false
+  })
+  return newestTime
+}

package/src/lib/openAPI/ApiBuildCollector.ts

@@ -5,43 +5,43 @@
  */
 import fs from 'fs'
 import path from 'path'
-import {recurseDirectory} from "../DirectoryUtils";
-import {resolvePaths} from "../pathResolve";
+import { recurseDirectory } from '../DirectoryUtils'
+import { resolvePaths } from '../pathResolve'
 
-
-export function gatherFunctionDefinitions():any[] {
-    const defs:any = []
-    try {
-        const projectPaths = resolvePaths();
-        if(!projectPaths.verified) return [];
-        const funcNames: string[] = [];
-        if(!fs.existsSync(projectPaths.functionPath)) return [];
-        let firstDepth = 0;
-        recurseDirectory(projectPaths.functionPath, (filepath, stats) => {
-            if (stats.isDirectory()) {
-                let depth = filepath.split(path.sep).length
-                if(!firstDepth) firstDepth = depth
-                if(firstDepth == depth) {
-                    funcNames.push(path.basename(filepath));
-                }
-            }
-        })
-        if(projectPaths.functionPath.indexOf('functions') !== -1 ) {
-            for (let name of funcNames) {
-                let defPath = path.join(projectPaths.functionPath, name, 'src', 'definition.json')
-                if (fs.existsSync(defPath)) {
-                    const content = fs.readFileSync(defPath).toString()
-                    let buildPath = path.join(projectPaths.buildPath, 'functions', name, 'src', 'definition.json')
-                    // fs.writeFileSync(buildPath, content); // use this opportunity to copy to build folder before we use it.
-                    defs.push(JSON.parse(content))
-                } else {
-                    console.error(`Definition file not found at ${defPath}`);
-                    return [];
-                }
-            }
+export function gatherFunctionDefinitions (): any[] {
+  const defs: any = []
+  try {
+    const projectPaths = resolvePaths()
+    if (!projectPaths.verified) return []
+    const funcNames: string[] = []
+    if (!fs.existsSync(projectPaths.functionPath)) return []
+    let firstDepth = 0
+    recurseDirectory(projectPaths.functionPath, (filepath, stats) => {
+      if (stats.isDirectory()) {
+        const depth = filepath.split(path.sep).length
+        if (firstDepth === 0) firstDepth = depth
+        if (firstDepth === depth) {
+          funcNames.push(path.basename(filepath))
+        }
+      }
+      return false
+    })
+    if (projectPaths.functionPath.includes('functions')) {
+      for (const name of funcNames) {
+        const defPath = path.join(projectPaths.functionPath, name, 'src', 'definition.json')
+        if (fs.existsSync(defPath)) {
+          const content = fs.readFileSync(defPath).toString()
+          // const buildPath = path.join(projectPaths.buildPath, 'functions', name, 'src', 'definition.json')
+          // fs.writeFileSync(buildPath, content); // use this opportunity to copy to build folder before we use it.
+          defs.push(JSON.parse(content))
+        } else {
+          console.error(`Definition file not found at ${defPath}`)
+          return []
         }
-    } catch(e: any) {
-        console.error("Exception in ApiBuildCollector", e)
+      }
     }
-    return defs;
+  } catch (e: any) {
+    console.error('Exception in ApiBuildCollector', e)
+  }
+  return defs
 }

package/src/lib/openAPI/WebrootFileSupport.ts

@@ -1,21 +1,19 @@
 
 import * as path from 'path'
-import {resolvePaths} from "../pathResolve";
-import {recurseDirectory} from "../DirectoryUtils";
+import { resolvePaths } from '../pathResolve'
+import { recurseDirectory } from '../DirectoryUtils'
 
+export function GetWebrootServePaths (): string[] {
+  const projectPaths = resolvePaths()
+  const webroot = path.join(projectPaths.basePath, 'webroot')
 
-export function GetWebrootServePaths(): string[]
-{
-    const projectPaths = resolvePaths();
-    const webroot = path.join(projectPaths.basePath, "webroot")
-
-    const list:string[] = [''];
-    recurseDirectory(webroot, (filepath, stats) => {
-        if(stats.isDirectory())
-        {
-            let relpath = filepath.substring(webroot.length);
-            if(list.indexOf(relpath) === -1) list.push(relpath);
-        }
-    })
-    return list;
-}
+  const list: string[] = ['']
+  recurseDirectory(webroot, (filepath, stats) => {
+    if (stats.isDirectory()) {
+      const relpath = filepath.substring(webroot.length)
+      if (!list.includes(relpath)) list.push(relpath)
+    }
+    return false
+  })
+  return list
+}