@tremho/mist-lift 1.0.0

package/src/commands/builtin/ApiDocMaker.ts

@@ -0,0 +1,70 @@
+import {gatherFunctionDefinitions} from "../../lib/openAPI/ApiBuildCollector";
+import {buildOpenApi} from "../../lib/openAPI/openApiConstruction";
+import {whiteBright} from "ansi-colors";
+import {GetWebrootServePaths} from "../../lib/openAPI/WebrootFileSupport";
+
+export async function MakePublicApiDoc
+(
+):Promise<Uint8Array>
+{
+    const defs = gatherFunctionDefinitions();
+    return await buildOpenApi(defs)
+}
+
+export async function MakeBuiltinApiDoc
+(
+    yamlFile:string
+
+):Promise<Uint8Array>
+{
+    const defs = gatherFunctionDefinitions()
+    addBuiltInDefinitions(defs)
+    return await buildOpenApi(defs, false, yamlFile) //, true)
+}
+
+export function addBuiltInDefinitions(defs:any[])
+{
+    // console.warn("NOT ADDING ANY BUILTIN API INTEGRATIONS")
+    // console.log("ADDING apiDef");
+    defs.push(apiDef);
+    // console.log("ADDING webrootDef");
+    defs.push(webrootDef);
+
+    // console.warn("Adding webroot literals");
+    // do just /docs and see how that goes
+    let fsdef = Object.assign({},fileServeDef); // copy
+    fsdef.name = "fileserve_docs"
+    fsdef.pathMap = "/docs/{path}"
+    defs.push(fsdef);
+    const roots = GetWebrootServePaths();
+    // console.log("roots", roots)
+    for(let root of roots)
+    {
+        if(root) {
+            let rootName = root;
+            while (rootName.indexOf("/") != -1) rootName = rootName.replace("/", "").toLowerCase().trim();
+            let fileserve = Object.assign({}, fileServeDef); // copy
+            fileserve.name = "fileserve_" + rootName
+            fileserve.pathMap = `${root}/{path}`
+            defs.push(fileserve);
+        }
+    }
+}
+
+const apiDef = {"name": "API", "description": "", "version": "1.0.0", "pathMap": "/api", "allowedMethods": "GET",
+    "logLevel": "Debug", "sessionRequired": false, "userRequired": false, "schemas": {}, "parameters": [],
+    "returns": { "200": {"type": "empty", "description": "successful response."}, "500": {"type": "string",
+    "description": "Error details"}}}
+
+const fileServeDef = {"name": "FileServe", "description": "file service", "version":
+        "1.0.0", "pathMap": "",
+    "allowedMethods": "GET", "logLevel": "Debug", "sessionRequired": false, "userRequired": false,
+    "schemas": {}, "parameters": [{"name": "path", "in": "path"}],
+    "returns": {"200": {"type": "empty", "description": "successful response."},
+    "500": {"type": "string", "description": "Error details"}}}
+
+const webrootDef = {"name": "Webroot", "description": "Serves files from the webroot /", "version": "1.0.0",
+    "pathMap": "/{path}", "allowedMethods": "get", "logLevel": "Debug", "sessionRequired": false, "userRequired": false,
+    "schemas": {}, "parameters": [{"name": "path", "in": "path"}],
+    "returns": {"200": {"type": "empty", "description": "successful response."},
+    "500": {"type": "string", "description": "Error details"}}}

package/src/commands/builtin/BuiltInHandler.ts

@@ -0,0 +1,51 @@
+import {StageWebrootZip} from "./StageWebrootZip";
+import {DeployBuiltInZip} from "./DeployBuiltInZip";
+import {GetWebrootServePaths} from "../../lib/openAPI/WebrootFileSupport";
+
+import fs from 'fs'
+import path from 'path'
+
+
+export async function DeployWebrootBuiltIn
+(
+)
+{
+    const wrZip = await StageWebrootZip()
+    // console.log("Deploy Webroot Builtin from "+wrZip)
+    await DeployBuiltInZip("Webroot", wrZip)
+    // remove temp zip when done
+    fs.rmSync(wrZip, {recursive: true});
+}
+
+export async function DeployRootFileserves
+(
+)
+{
+    // console.log("Deploy Root Fileserves")
+    // Get root paths
+    const roots = GetWebrootServePaths();
+    // for each, deploy under the name of each
+    const fileserveZip = path.join(__dirname, 'prebuilt-zips', 'FileServe.zip')
+    let all:Promise<any>[] = [];
+    for(let root of roots) {
+        root = root.trim()
+        let name = "fileserve_" + root;
+        while (name.indexOf("/") !== -1) {
+            name = name.replace('/', '');
+        }
+        all.push(DeployBuiltInZip(name, fileserveZip))
+    }
+    // console.log('wait all');
+    await Promise.all(all);
+    // console.log('all complete');
+}
+
+export async function DeployApiBuiltin
+(
+):Promise<any>
+{
+    console.log("Deploy API Builtin")
+    // get the prebuilt zip location
+    const apiZip = path.join(__dirname, 'prebuilt-zips', 'API.zip')
+    await DeployBuiltInZip("api", apiZip)
+}

package/src/commands/builtin/DeployBuiltInZip.ts

@@ -0,0 +1,27 @@
+
+import * as path from 'path'
+import {deployPackage} from '../deploy'
+
+export async function DeployBuiltInZip
+(
+    name:string,
+    zipPath:string
+)
+{
+    // console.log(">> Deploying "+name)
+    await deployPackage(name, zipPath);
+}
+
+export async function DeployFileserve
+(
+    root:string
+)
+{
+    // rootName is without slash
+    if(root) {
+        let rootName = root.replace("/", "")
+        let name = "fileserve_" + rootName
+        let zipPath = path.join(__dirname, 'prebuilt-zips', 'FileServe.zip')
+        await DeployBuiltInZip(name, zipPath)
+    }
+}

package/src/commands/builtin/StageWebrootZip.ts

@@ -0,0 +1,39 @@
+import {MakePublicApiDoc} from "./ApiDocMaker";
+
+import * as ac from "ansi-colors"
+import * as path from 'path'
+import * as fs from 'fs'
+import {executeCommand} from "../../lib/executeCommand";
+import {resolvePaths} from "../../lib/pathResolve";
+import {recurseDirectory} from "../../lib/DirectoryUtils";
+import {FolderToZip, UnzipToFolder} from "../../lib/utils";
+
+export async function StageWebrootZip
+(
+):Promise<string>
+{
+    // console.log(">> staging webroot to zip")
+    const projectPaths = resolvePaths();
+    // make a public yaml
+    await MakePublicApiDoc(); // writes apidoc.yaml to docs
+    const builtinPath = path.join(__dirname, 'prebuilt-zips', 'Webroot.zip')
+    const exdir = path.join(projectPaths.basePath, '.package_temp');
+    await UnzipToFolder(builtinPath, exdir)
+    const webroot = path.join(projectPaths.basePath, 'webroot');
+    const packageTemp = path.join(projectPaths.basePath, '.package_temp')
+    const zipFilesPath = path.join(packageTemp, 'Webroot','__files__')
+    await recurseDirectory(webroot, (filepath, stats) => {
+        const relPath = filepath.substring(webroot.length)
+        if(stats.isDirectory()) {
+            fs.mkdirSync(zipFilesPath+relPath, {recursive: true})
+        } else {
+            fs.copyFileSync(filepath, zipFilesPath + relPath)
+        }
+    })
+    const webrootZip = path.join(projectPaths.basePath, 'a.zip')
+
+    await FolderToZip(path.join(packageTemp, 'Webroot'), webrootZip)
+    // return path to this zip
+    return webrootZip
+
+}

package/src/commands/create.ts

@@ -0,0 +1,55 @@
+/** Handles fucntion creation via the create command */
+
+import * as fs from 'fs'
+import * as path from 'path'
+import * as ac from "ansi-colors"
+import {resolvePaths} from "../lib/pathResolve";
+import {camelCase, pascalCase} from "../lib/CaseUtils"
+import {helpCreate} from "./help";
+
+
+/// Create command
+export function doCreate(
+    funcName:string // name of function to create
+)
+{
+        if(!funcName) {
+                helpCreate()
+                return
+        } else {
+
+        console.log(ac.green.bold("Creating new function named ")+funcName)
+
+        const projectPaths = resolvePaths();
+        const funcPath = path.join(projectPaths.functionPath, funcName);
+        if(!fs.existsSync(funcPath)) fs.mkdirSync(funcPath)
+        const dataDir = path.join(__dirname, '..', '..', 'templateData');
+
+        const testdirname = camelCase(funcName) + '-tests';
+        if(!fs.existsSync(path.join(funcPath, testdirname))) fs.mkdirSync(path.join(funcPath, testdirname))
+        if(!fs.existsSync(path.join(funcPath, 'src'))) fs.mkdirSync(path.join(funcPath, 'src'))
+
+        let localsrc = fs.readFileSync(path.join(dataDir, 'function-local-ts')).toString();
+        while (localsrc.indexOf("$$FUNCTION_NAME$$") !== -1) {
+            localsrc = localsrc.replace("$$FUNCTION_NAME$$", funcName);
+        }
+        fs.writeFileSync(path.join(funcPath, 'src', 'local.ts'), localsrc);
+        let defsrc = fs.readFileSync(path.join(dataDir, 'function-definition-template')).toString();
+        while(defsrc.indexOf("$$FUNCTION_NAME$$") !== -1) {
+            defsrc = defsrc.replace("$$FUNCTION_NAME$$", funcName);
+        }
+        let defpathMap = "/"+funcName.toLowerCase();
+        defsrc = defsrc.replace("$$PATHMAP$$", defpathMap)
+        fs.writeFileSync(path.join(funcPath, 'src', 'definition.json'), defsrc);
+        let mainsrc = fs.readFileSync(path.join(dataDir, 'function-main-ts')).toString();
+        while(mainsrc.indexOf("$$TemplateName$$") !== -1) {
+            mainsrc = mainsrc.replace("$$TemplateName$$", funcName);
+        }
+        fs.writeFileSync(path.join(funcPath, 'src', 'main.ts'), mainsrc);
+        fs.copyFileSync(path.join(dataDir, 'function-test-template'), path.join(funcPath, testdirname, 'Sanity.test.ts'))
+        fs.copyFileSync(path.join(dataDir, 'function-runmain-mjs'), path.join(funcPath, 'runmain.mjs'));
+
+    }
+
+}
+

package/src/commands/deploy.ts

@@ -0,0 +1,171 @@
+
+import {
+    LambdaClient,
+    CreateFunctionCommand,
+    DeleteFunctionCommand,
+    AddPermissionCommand
+} from "@aws-sdk/client-lambda";
+
+import md5 from "md5";
+
+import path from "path"
+import fs, {Stats} from "fs"
+import {resolvePaths} from "../lib/pathResolve"
+
+import * as ac from "ansi-colors"
+
+import {doTestAsync} from  "./test"
+import {recurseDirectory} from "../lib/DirectoryUtils"
+import {getLiftVersion, getProjectName, getProjectVersion} from "../lib/LiftVersion"
+import {executeCommand} from "../lib/executeCommand"
+import {isNewerFile} from "../lib/fileCompare"
+import {delay} from "../lib/utils"
+import {doBuildAsync} from "./build";
+import {doPackageAsync} from "./package";
+import {Md5} from "@smithy/md5-js";
+import {getAWSCredentials, getSettings, RuntimeType} from "../lib/LiftConfig";
+
+let projectPaths:{basePath: string, buildPath: string, functionPath: string, packagePath: string, verified: boolean}
+
+let deploymentRecord:any = {} // a map of last deployment times
+
+// package then deploy
+export async function doDeployAsync(
+    args:string[]
+): Promise<number>
+{
+    projectPaths = resolvePaths()
+
+    const deploymentRecordPath = path.join(projectPaths.basePath, '.deployed')
+    try { deploymentRecord = JSON.parse(fs.readFileSync(deploymentRecordPath).toString()) } catch {}
+
+    // the main package json that has all imports
+    const mainPkgJsonPath = path.join(projectPaths.packagePath)
+    const mainPkgSrc = fs.readFileSync(mainPkgJsonPath).toString()
+    const mainPkgJson = JSON.parse(mainPkgSrc)
+
+    const projectName = getProjectName()
+    const projectVersion = getProjectVersion()
+    const liftVersion = getLiftVersion()
+
+    const funcsToDeploy: string[] = []
+    const options: string[] = []
+    for (let arg of args) {
+        if (arg.charAt(0) == '-') {
+            options.push(arg.toLowerCase())
+        } else funcsToDeploy.push(arg)
+    }
+
+    if (options.indexOf("--no-package") === -1) {
+        let ret = await doPackageAsync(args)
+        if (ret) return ret;
+        else await delay(2500);
+    }
+
+    if(options.indexOf("--clean") !== -1) {
+        deploymentRecord = {};
+    }
+
+    if (!funcsToDeploy.length) {
+        let firstDepth = 0
+        recurseDirectory(projectPaths.functionPath, (filepath, stats) => {
+            let depth = filepath.split(path.sep).length
+            if (!firstDepth) firstDepth = depth
+            if (stats.isDirectory() && depth == firstDepth) {
+                funcsToDeploy.push(path.basename(filepath))
+            }
+        })
+    }
+
+    const all: Promise<any>[] = [];
+    let error = 0;
+
+    for (let funcName of funcsToDeploy) {
+        // console.log("Deploy "+funcName)
+        const zipFile = path.join(projectPaths.basePath, 'MistLift_Zips', funcName+".zip")
+        if(fs.existsSync(zipFile)) {
+            let zipTime = fs.statSync(zipFile).mtime;
+            if(zipTime.getTime() > (deploymentRecord[funcName] ?? 0)) {
+                await deployPackage(funcName);
+                deploymentRecord[funcName] = Date.now();
+            }
+        } else {
+            console.error("deploy: " +zipFile + ac.red.bold(` ${funcName} does not exist`))
+            return -1;
+        }
+    }
+
+    try {fs.writeFileSync(deploymentRecordPath, JSON.stringify(deploymentRecord)) } catch {}
+
+    return 0;
+}
+
+//------------
+
+export async function deployPackage(funcName:string, zipFile?:string) {
+    // first off, anchor a base directory
+    zipFile ??= path.join(projectPaths.basePath, 'MistLift_Zips', funcName+".zip")
+
+    // funcname gets decorated with current instance identifier
+    var idsrc = md5((getProjectName()??"") + (getProjectVersion()??""))
+    var dFuncName = funcName + "_"+idsrc
+
+    // See if function exists
+    const client:any = new LambdaClient(getAWSCredentials());
+    const command:any = new DeleteFunctionCommand({
+        FunctionName: dFuncName
+    });
+    client.send(command).then((response:any) => {
+    }).catch((e:any) =>  {
+    });
+
+    // console.log(ac.green.italic("deploying ")+ac.green.bold(funcName)+"...")
+
+    try {
+        const response:any = await CreateCloudFunction(dFuncName, zipFile);
+        const parts = response.FunctionArn.split(":");
+        const principal = parts[4]
+        await AddPermissions(client, dFuncName, principal);
+        console.log(ac.green.bold(`Successfully deployed ${funcName}`));
+    }
+    catch(e:any) {
+        console.error(ac.red.bold.italic("Error deploying "+funcName), e);
+    }
+}
+async function CreateCloudFunction(
+    funcName:string,
+    zipFile:string
+
+) : Promise<any>
+{
+
+    const settings = getSettings();
+    const nodeRuntime:RuntimeType|undefined = settings.awsNodeRuntime
+    const serviceRole:string = settings.awsServiceRoleARN ?? ""
+    const zipFileBase64:Uint8Array = fs.readFileSync(zipFile);
+    const client:any = new LambdaClient(getAWSCredentials());
+    const command:any = new CreateFunctionCommand({
+        FunctionName: funcName,
+        Runtime: nodeRuntime,
+        Role: serviceRole,
+        Handler: 'runmain.handler',
+        Code: {
+            ZipFile: zipFileBase64
+        }
+    });
+    return await client.send(command); // response
+}
+
+function AddPermissions(client:LambdaClient, funcName:string, principal:string):Promise<any>
+{
+    const region = getSettings().awsPreferredRegion
+    const WSApi = "/"+funcName.toLowerCase();
+    const command:any = new AddPermissionCommand({
+        FunctionName: funcName,
+        StatementId: "InvokePermission",
+        Action: "lambda:invokeFunction",
+        Principal: "apigateway.amazonaws.com",
+        SourceArn: `arn:aws:execute-api:${region}:${principal}:${WSApi}`
+    });
+    return client.send(command);
+}

package/src/commands/doctor.ts

@@ -0,0 +1,102 @@
+
+import * as ac from "ansi-colors"
+import {VersionInfo, getLiftVersion, getProjectVersion, getProjectName} from "../lib/LiftVersion";
+import {executeCommand} from "../lib/executeCommand"
+import {resolvePaths} from "../lib/pathResolve";
+import {areSettingsAvailable} from "../lib/LiftConfig";
+
+export async function doDoctor():Promise<boolean>
+{
+    console.log(ac.blue.bold('Lift doctor'));
+
+    const liftVersion = getLiftVersion().toString()
+    const projectVersion = getProjectVersion().toString()
+    const projectName = getProjectName();
+    const typescriptVersion = await fetchTypescriptVersion()
+    const nodeVersion = await fetchNodeVersion()
+    const npmVersion = await fetchNpmVersion()
+    const gitVersion = await fetchGitVersion();
+    const settingsAvail = areSettingsAvailable();
+
+    console.log("Checking installed dependencies:")
+    let ok = report("MistLift", liftVersion, "0.1.0")
+    ok = ok && report("Typescript", typescriptVersion, "5.3.3")
+    ok = ok && report("Node", nodeVersion, "20.11.0")
+    ok = ok && report("Npm", npmVersion, "10.3.0")
+    report("Git", gitVersion, "2.0.0")
+    if(!settingsAvail) {
+        console.log("")
+        console.log(ac.yellow.dim.bold("Cloud Settings are not set. ")+ac.blue("run "+ac.bold("lift settings")))
+    }
+    if(!ok) {
+        console.log("")
+        console.log(ac.red.bold("System needs updates before MistLift can be used."));
+    } else {
+        console.log("")
+        console.log(ac.green.bold("Ready for MistLift"))
+        console.log("");
+        if(resolvePaths().verified) {
+            console.log(ac.blue.italic("Current project " + projectName + " " + projectVersion))
+        }
+    }
+    return ok
+}
+
+function versionTrim(vstr:string)
+{
+    vstr = vstr.trim();
+    let i = -1;
+    while(++i < vstr.length) {
+        let c = vstr.charAt(i);
+        if(c >= '0' && c <= '9') break;
+    }
+    return vstr.substring(i);
+}
+
+async function fetchTypescriptVersion()
+{
+    const result = await executeCommand('tsc', ['-v'])
+    if(result.retcode) return "Typescript not found"
+    var vstr = versionTrim(result.stdStr);
+    return vstr;
+}
+
+async function fetchNodeVersion()
+{
+    const result = await executeCommand('node', ['-v'])
+    if(result.retcode) return "Node not found"
+    var vstr = versionTrim(result.stdStr);
+    return vstr;
+
+}
+
+async function fetchNpmVersion()
+{
+    const result = await executeCommand('npm', ['-v'])
+    if(result.retcode) return "npm not found"
+    var vstr = versionTrim(result.stdStr);
+    return vstr;
+}
+
+async function fetchGitVersion()
+{
+    const result = await executeCommand('git', ['-v'])
+    if(result.retcode) return "Git not found"
+    var vstr = versionTrim(result.stdStr);
+    return vstr;
+}
+
+// compare to a minimum and report ok or error
+
+function report(name:string, version:string, minStr:string):boolean
+{
+    const ver = new VersionInfo(version);
+    const minVer = new VersionInfo(minStr);
+    let ok = (ver.isGreaterThan(minVer) || ver.equals(minVer))
+    if(ok) {
+        console.log(ac.green.bold("√ ")+ac.black.bold(name)+" "+ac.grey(version))
+    } else {
+        console.log(ac.red.bold("X ")+ac.black.bold(name)+ac.red.bold(" does not meet minimum version of ")+ac.blue(minStr))
+    }
+    return ok;
+}