@tremho/mist-lift 1.0.0

package/src/expressRoutes/functionBinder.ts

@@ -0,0 +1,169 @@
+import path from "path";
+import fs from "fs";
+
+const clearModule = require('clear-module')
+
+import * as ac from "ansi-colors"
+import {resolvePaths} from "../lib/pathResolve";
+import {GetWebrootServePaths} from "../lib/openAPI/WebrootFileSupport"
+import {doBuildAsync} from "../commands/build"
+
+
+import express from 'express'
+import {gatherFunctionDefinitions} from "../lib/openAPI/ApiBuildCollector";
+import {buildOpenApi} from "../lib/openAPI/openApiConstruction";
+const router = express.Router();
+
+
+export function functionBinder() {
+    const defs = gatherFunctionDefinitions();
+    buildOpenApi(defs).then(() => { // creates apidoc.yaml for when /api is run
+
+
+        const projectPaths = resolvePaths();
+
+        for (let def of defs) {
+            const {name, pathMap, allowedMethods} = def;
+            const methods = allowedMethods.split(',');
+            for (let method of methods) {
+                method = method.trim().toLowerCase();
+                let rpath = path.join(projectPaths.buildPath, 'functions', name, 'src', 'main.js')
+                clearModule(rpath);
+                const {start} = require(rpath);
+
+                let entryRoot = pathMap;
+                let n = entryRoot.indexOf("/{");
+                if (n !== -1) entryRoot = entryRoot.substring(0, n) + "/*";
+
+                const callNoBody = (pathMap: string, req: any, res: any) => {
+                    const event = requestToEvent(pathMap, req)
+                    Promise.resolve(start(event, null, null)).then(respOut => {
+                        handleResponse(res, respOut);
+                    })
+                }
+                const callWithBody = (pathMap: string, req: any, res: any) => {
+                    const event = requestToEvent(pathMap, req)
+                    event.body = req.body
+                    Promise.resolve(start(event, null, null)).then(respOut => {
+                        handleResponse(res, respOut);
+                    })
+                }
+
+                if (method === 'get') {
+                    router.get(entryRoot, (req, res) => callNoBody(pathMap, req, res))
+                } else if (method === 'post') {
+                    router.get(entryRoot, (req, res) => callWithBody(pathMap, req, res))
+                } else if (method === 'put') {
+                    router.put(entryRoot, (req, res) => callWithBody(pathMap, req, res))
+                } else if (method === 'patch') {
+                    router.patch(entryRoot, (req, res) => callWithBody(pathMap, req, res))
+                } else if (method === 'delete') {
+                    router.delete(entryRoot, (req, res) => callNoBody(pathMap, req, res))
+                } else {
+                    console.log(ac.red.bold("Cannot map method ") + ac.blue.bold(method))
+                }
+
+            }
+        }
+    })
+}
+
+function requestToEvent(template:string, req:any) {
+    let path = req.originalUrl
+    const qi = path.indexOf('?');
+    if(qi !== -1) path = path.substring(0,qi);
+    let ptci = path.indexOf("://")+3;
+    let ei = path.indexOf("/", ptci);
+    let host = path.substring(0, ei);
+    if(ptci < 3) {
+        host = req.headers?.origin;
+        if(!host) {
+            host = req.headers?.referer ?? "";
+            let ptci = path.indexOf("://")+3;
+            let ei = path.indexOf("/", ptci);
+            host = ptci > 3 ? path.substring(0, ei) : "";
+        }
+        if(!host) {
+            // todo: http or https?
+            host = "http://"+req.headers?.host ?? "";
+        }
+    }
+    var cookies:any = {};
+    var cookieString = req.headers?.cookie ?? "";
+    var crumbs = cookieString.split(';')
+    for(let c of crumbs) {
+        const pair:string[] = c.split('=');
+        if(pair.length === 2) cookies[pair[0]] = pair[1]
+    }
+    const parameters:any = {}
+    const tslots = template.split('/');
+    const pslots = path.split('/');
+    for(let i = 0; i< tslots.length; i++) {
+        const brknm = (tslots[i]??"").trim();
+        if(brknm.charAt(0) === '{') {
+            const pn = brknm.substring(1, brknm.length - 1);
+            parameters[pn] = (pslots[i]??"").trim();
+        }
+    }
+    for(let p of Object.getOwnPropertyNames(req.query)) {
+        parameters[p] = req.query[p]
+    }
+    const eventOut:any = {
+        requestContext: req,
+        request: {
+            originalUrl: host + req.originalUrl,
+            headers: req.headers
+        },
+        cookies,
+        parameters
+    }
+    return eventOut;
+}
+function handleResponse(res:any, resp:any)
+{
+    // console.log(">>>>>>>> Handling response >>>>>>>>>")
+
+    if(resp) {
+        if (resp.cookies !== undefined) {
+            // console.log("--- see cookies", resp.cookies)
+            var cookies:any = []
+            if(Array.isArray(resp.cookies)) {
+                cookies = resp.cookies
+            } else {
+                var age = resp.cookies.expireSeconds ?? 60; // 1 minute
+                delete resp.expireSeconds;
+                Object.getOwnPropertyNames(resp.cookies).forEach(name => {
+                    var value = resp.cookies[name];
+                    cookies.push(`${name}=${value}; Max-Age=${age}; `);
+                })
+            }
+            // console.log("cookies being set", cookies)
+            res.setHeader("set-cookie", cookies);
+            delete resp.cookies;
+        }
+        if (resp.headers !== undefined) {
+            // if (resp.statusCode === 301) ClogTrace("Redirecting...");
+            for (var hdr of Object.getOwnPropertyNames(resp.headers)) {
+                // ClogTrace("Setting header ", hdr, resp.headers[hdr]);
+                res.setHeader(hdr, resp.headers[hdr])
+            }
+            delete resp.headers;
+            // console.log("past setting headers");
+        }
+        if (resp.statusCode !== undefined) {
+            res.statusCode = resp.statusCode;
+            delete resp.statusCode
+        }
+
+        if (resp.contentType !== undefined) {
+            res.setHeader("Content-Type", resp.contentType);
+            delete resp.contentType
+        }
+        if(resp.body) resp = resp.body;
+    }
+    // console.log("headers to be sent", res.getHeaders())
+    // console.log("-- Sending response", resp)
+    res.send(resp);
+}
+
+export default router

package/src/lib/CaseUtils.ts

@@ -0,0 +1,68 @@
+
+// separate a case-joined string into a string of space-separated words
+export function separated(
+    instr:string
+):string
+{
+    let outstr = '';
+    for(let i=0; i<instr.length; i++) {
+        let c = instr.charAt(i);
+        if(!isAlphaNum(c) || isUpperCase(c)) {
+            outstr += ' ';
+        }
+        outstr += c.toLowerCase();
+    }
+
+    return outstr.trim()
+}
+
+function isUpperCase(instr:string) {
+    return instr?.toUpperCase() === instr
+}
+function isAlphaNum(char:string) {
+    let alnum = false
+    const cc = char.toUpperCase().charCodeAt(0)
+    if(cc >= 'A'.charCodeAt(0) && cc <= 'Z'.charCodeAt(0)) alnum = true
+    if(cc >= '0'.charCodeAt(0) && cc <= '9'.charCodeAt(0)) alnum = true
+    return alnum
+}
+
+export function camelCase(
+    instr:string
+):string
+{
+    const seps = separated(instr).split(' ')
+    for(let i=1; i<seps.length; i++) {
+        seps[i] = seps[i].charAt(0).toUpperCase()+seps[i].substring(1)
+    }
+    return seps.join('')
+}
+
+export function pascalCase(
+    instr:string
+):string
+{
+    const seps = separated(instr).split(' ')
+    for(let i=0; i<seps.length; i++) {
+        seps[i] = seps[i].charAt(0).toUpperCase()+seps[i].substring(1)
+    }
+    return seps.join('')
+}
+
+export function snakeCase(
+    instr:string
+):string
+{
+    return dashCase(instr, "_")
+}
+export function dashCase(
+    instr:string,
+    dashChar: string = '-',
+    allCaps: boolean = false
+):string
+{
+    const seps = separated(instr).split(' ')
+    let out = seps.join(dashChar)
+    if(allCaps) out = out.toUpperCase();
+    return out;
+}

package/src/lib/DirectoryUtils.ts

@@ -0,0 +1,36 @@
+
+import fs from 'fs';
+import {Stats} from 'fs'
+import path from 'path'
+
+// Callback definition for recurseDirectory
+export interface RecurseCB {
+    (filepath: string, stats: Stats): boolean|void;
+}
+
+// Recurse a directory, calling back to a 'for-each' callback for all files in tree
+export function recurseDirectory(dirpath:string, callback:RecurseCB) {
+    fs.readdirSync(dirpath).forEach((file:string) => {
+        const fpath = path.join(dirpath, file)
+        const stat = fs.lstatSync(fpath)
+        if(callback && !callback(fpath, stat)) {
+            if (stat.isDirectory()) {
+                recurseDirectory(fpath, callback)
+            }
+        }
+    })
+}
+
+// find the latest mod time for matching files in this folder tree
+export function latestModification(dirpath:string, match:string) {
+    let latestTime = new Date(0);
+    if(fs.existsSync(dirpath)) {
+        recurseDirectory(dirpath, (filepath: string, stats: Stats) => {
+            let basefile = filepath.substring(filepath.lastIndexOf('/') + 1)
+            if (basefile.match(match)) {
+                if (stats.mtime > latestTime) latestTime = stats.mtime
+            }
+        })
+    }
+    return latestTime
+}

package/src/lib/LiftConfig.ts

@@ -0,0 +1,83 @@
+// configuration for setting cloud provider credentials
+// may expand later for other MistLift settings/preferences
+
+import path from "path";
+import fs from "fs";
+import AWS, {fromIni} from '@aws-sdk/credential-providers';
+import {NodeJsRuntimeStreamingBlobTypes} from "@smithy/types";
+
+let s_liftConfigLoaded:LiftConfig|null = null;
+
+// Defines the structure of the .mistlft json file
+// All relevant configuration for the cloud host goes here
+export class LiftConfig {
+    public cloudHost: string = "AWS" // all we support now
+    public awsIniProfile?: string
+    public awsPreferredRegion?:string
+    public awsNodeRuntime?: RuntimeType
+    public awsServiceRoleARN?:string
+}
+export type RuntimeType = "nodejs" | "nodejs4.3" | "nodejs6.10" | "nodejs8.10" | "nodejs10.x" | "nodejs12.x" | "nodejs14.x" | "nodejs16.x" | "java8" | "java8.al2" | "java11" | "python2.7" | "python3.6" | "python3.7" | "python3.8" | "python3.9" | "dotnetcore1.0" | "dotnetcore2.0" | "dotnetcore2.1" | "dotnetcore3.1" | "dotnet6" | "dotnet8" | "nodejs4.3-edge" | "go1.x" | "ruby2.5" | "ruby2.7" | "provided" | "provided.al2" | "nodejs18.x" | "python3.10" | "java17" | "ruby3.2" | "ruby3.3" | "python3.11" | "nodejs20.x" | "provided.al2023" | "python3.12" | "java21";
+
+// Available for general use because, why not?
+export function getUserHome() {
+    return process.env.HOME ?? process.env.HOMEPATH ?? process.env.USERPROFILE ?? "~";
+}
+
+export function LoadLiftConfig() : LiftConfig|null
+{
+    if(!s_liftConfigLoaded) {
+
+        const mistlift = path.join(getUserHome(), ".mistlift");
+        let configJson = "{}";
+        if (fs.existsSync(mistlift)) {
+            try {
+                configJson = fs.readFileSync(mistlift).toString();
+                s_liftConfigLoaded = JSON.parse(configJson);
+            } catch (e: any) {
+                //
+            }
+        }
+    }
+    return s_liftConfigLoaded
+}
+export function resetLiftConfig()
+{
+    s_liftConfigLoaded = null;
+}
+
+export function areSettingsAvailable():boolean {
+    const mistlift = path.join(getUserHome(), ".mistlift");
+    return fs.existsSync(mistlift);
+}
+
+export function getSettings() : LiftConfig {
+    if (s_liftConfigLoaded == null) LoadLiftConfig();
+    return s_liftConfigLoaded as LiftConfig
+}
+
+/**
+ * Return the credentials required for AWS based upon our config options.
+ *
+ * We will use the standard .aws config ini file, looked up by profile or default
+ * Prior attempts to have it do more than this failed, and resulted in a default profile choice anyway.
+ */
+export function getAWSCredentials() : any
+{
+    let config = LoadLiftConfig()
+    if(!config) {
+        // console.error("No .mistlift configuration found - using AWS default profile");
+        config = { cloudHost: "AWS", awsIniProfile: "default" }
+    }
+    if (config.cloudHost?.toUpperCase() !== "AWS")
+    {
+        throw Error("HostType Not Supported");
+    }
+    let credentials = {};
+    const profile = config.awsIniProfile ?? "default"
+    if(profile) {
+        credentials = fromIni({profile})
+    }
+
+    return credentials;
+}

package/src/lib/LiftVersion.ts

@@ -0,0 +1,95 @@
+
+import * as path from 'path'
+import * as fs from 'fs'
+import {resolvePaths} from "./pathResolve";
+
+export class VersionInfo
+{
+    public major:number = 0
+    public minor:number = 0
+    public revision:number = 0
+    public suffix:string = "";
+
+    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);
+    }
+}
+
+// read version from Lift's package.json
+export function getLiftVersion()
+{
+    let 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 getProjectName()
+{
+    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 ?? "")
+
+}
+
+

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

@@ -0,0 +1,34 @@
+
+import Tap from "tap"
+
+import * as path from 'path'
+import {isNewer, isNewerFile} from "../fileCompare";
+
+function test(t:any) {
+
+// ./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()
+}
+Tap.test('IsNewer', t => {
+    test(t)
+})

package/src/lib/askQuestion.ts

@@ -0,0 +1,18 @@
+/** handles interaction for asking a question */
+
+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
+
+) :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

@@ -0,0 +1,38 @@
+
+import {exec} from 'child_process'
+import * as path from 'path'
+
+export function executeCommand(cmd:string, args:any[],  cwd = '', consolePass = false, env:any = {}):Promise<any> {
+    const out = {
+        stdStr: '',
+        errStr: '',
+        retcode: 0
+    }
+    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)
+        })
+    })
+}

package/src/lib/fileCompare.ts

@@ -0,0 +1,46 @@
+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 = "";
+
+    if(mappingObj[ext]) newExt = mappingObj[ext];
+
+    let 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)
+}
+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
+                }
+            }
+        }
+    })
+    return newestTime;
+
+}

package/src/lib/openAPI/ApiBuildCollector.ts

@@ -0,0 +1,47 @@
+/**
+ * Part 1 of two steps to build openApi docs.
+ * This reads values from our "definitions.json" format and creates a single array that step 2 will turn into
+ * openApi specifications.
+ */
+import fs from 'fs'
+import path from 'path'
+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 [];
+                }
+            }
+        }
+    } catch(e: any) {
+        console.error("Exception in ApiBuildCollector", e)
+    }
+    return defs;
+}

package/src/lib/openAPI/WebrootFileSupport.ts

@@ -0,0 +1,21 @@
+
+import * as path from 'path'
+import {resolvePaths} from "../pathResolve";
+import {recurseDirectory} from "../DirectoryUtils";
+
+
+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;
+}