@tremho/mist-lift 1.0.0

package/src/lib/openAPI/openApiConstruction.ts

@@ -0,0 +1,202 @@
+/**
+ * This is part 2 of 2 -- we take our pre-built json array of definitions and apply them to openApi in this phase.
+ */
+import { OpenApiBuilder } from 'openapi3-ts/oas30';
+import fs, {mkdirSync} from 'fs'
+import path from 'path'
+import {resolvePaths} from "../pathResolve";
+import {recurseDirectory} from "../DirectoryUtils";
+import {getSettings} from "../LiftConfig";
+
+export async function buildOpenApi(
+    defs:any[],
+    includePrivate:boolean = false,
+    yamlFile?:string
+):Promise<Uint8Array>
+{
+    const builder = new OpenApiBuilder();
+
+    const projectPaths = await resolvePaths();
+    if(!projectPaths.verified) return new Uint8Array(0); // don't continue if not valid
+
+    // Read our package.json and construct info from that
+    const pkgFile = projectPaths.packagePath;
+    let pkg:any = {}
+    try { pkg = JSON.parse(fs.readFileSync(pkgFile).toString()); } catch {}
+    let title = pkg.name;
+    // let summary = pkg.description;
+    let spdx = pkg.license;
+    let contactName = pkg.author;
+    let version = pkg.version;
+
+    // license and version definitely come from package.json
+    // description and title might get overridden by service.info file
+    const infoFile = path.join(projectPaths.functionPath, "apiService.info.json")
+    var svcInfo:any = {};
+    if(fs.existsSync(infoFile)) {
+        svcInfo = JSON.parse(fs.readFileSync(infoFile).toString())
+    }
+    spdx = svcInfo.contact?.spdx ?? spdx;
+
+    const info = {
+        title: svcInfo.name ?? title,
+        // summary: summary,
+        description: svcInfo.description,
+        version: svcInfo.version ?? version ?? new Date().toUTCString()
+    }
+    builder.addInfo(info)
+
+    // map our defs into openApi values
+    for (let def of defs) {
+        let pathDef = {}
+        if(def.private && !includePrivate) continue; // skip private
+
+        const parameters = def.parameters ?? []
+        const methods = def.allowedMethods.split(',')
+        const schemas = def.schemas ?? {}
+        for(let schemaName of Object.getOwnPropertyNames(schemas)) {
+            const schema = schemas[schemaName];
+            addTypeSchema(builder, schemaName, schema)
+        }
+        for (let method of methods) {
+            method = method.trim().toLowerCase()
+            addFunctionMethod(pathDef, method, def)
+            for (let param of parameters) {
+                addParameter(pathDef, param)
+            }
+        }
+        addCORSOptionMethod(pathDef)
+        builder.addPath((def.pathMap ?? "/"+def.name), pathDef)
+
+        builder.addSchema("Empty",{
+            title : "Empty Schema",
+            type:"object"
+        })
+    }
+
+    const outFile = yamlFile ?? path.join(projectPaths.basePath, 'webroot', 'docs','apidoc.yaml')
+
+    const str2ab = (str:string):Uint8Array => {
+        var buf = new ArrayBuffer(str.length * 2); // 2 bytes for each char
+        var bufView = new Uint8Array(buf);
+        for (var i = 0, strLen = str.length; i < strLen; i++) {
+            bufView[i] = str.charCodeAt(i);
+        }
+        return bufView;
+    }
+
+    const yaml = builder.getSpecAsYaml();
+    const bytes = str2ab(yaml);
+    if(!includePrivate) {
+        fs.writeFileSync(outFile, yaml)
+    }
+    return bytes
+}
+
+function addTypeSchema(builder:any, schemaName:string, schema:any)
+{
+    const ref:any = {title: schemaName, type:"object", properties:{}}
+    for(let prop of Object.getOwnPropertyNames(schema))
+    {
+        const scType:any = schemaType("", schema[prop],false)
+
+        ref.properties[prop] = scType
+    }
+
+    builder.addSchema(schemaName, ref)
+}
+
+function addFunctionMethod(pathDef:any, method:string, def:any) {
+
+    // TODO: Define a return schema and put that here
+    const retDef:any = (def.returns as any)["200"];
+    const content:any = {}
+    const mime = retDef?.content ?? retDef?.mime ?? "text/plain"
+    content[mime] = {}
+
+    const region = getSettings().awsPreferredRegion;
+    const accountId = "545650260286";
+    const methData = {
+        summary: def.name,
+        description: def.description,
+        responses: {
+            "200": {
+                description: retDef?.description ?? "Success Response",
+                content
+            }
+        }
+    }
+    pathDef[method] = methData;
+}
+function addCORSOptionMethod(pathDef:any) {
+    if (pathDef["options"]) return; // already assinged by definition
+    // add options for CORS
+    pathDef["options"] = {
+        "responses" : {
+            "200" : {
+                "description" : "200 response",
+                "content" : {
+                    "application/json" : {
+                        "schema" : {
+                            "$ref" : "#/components/schemas/Empty"
+                        }
+                    }
+                }
+            }
+        },
+        "x-amazon-apigateway-integration" : {
+            "responses" : {
+                "default" : {
+                    "statusCode" : "200"
+                }
+            },
+            "requestTemplates" : {
+                "application/json" : "{\"statusCode\": 200}"
+            },
+            "passthroughBehavior" : "when_no_match",
+            "type" : "mock"
+        }
+    }
+}
+
+function addParameter(pathDef:any, param:any) {
+    if(!pathDef.parameters) pathDef.parameters = [];
+    const parameters = pathDef.parameters
+    const example = param.example ?? param.default ?? "";
+    const type = param.type ?? typeof example
+    let deflt = param.default ?? example
+
+    parameters.push({
+        in: param.in,
+        name: param.name,
+        description: param.description,
+        example: example,
+        required: param.required,
+        schema: schemaType(deflt, type, true)
+    })
+
+}
+
+function schemaType(deflt:string, namedType:string, innerOnly:boolean) {
+    if(typeof namedType == "object") return namedType;
+    const typeFormat = namedType.split(':')
+    let type = typeFormat[0]
+    const format = typeFormat.length > 1 ? typeFormat[1] : undefined
+    if(!(  type === "string"
+        || type === "number"
+        || type === "integer"
+        || type === "boolean"
+        || type === "int"
+        || type === "bool"
+    )) {
+        return innerOnly ? {
+            $ref: `#/components/schemas/${type}`
+        } : { schema: {
+                $ref: `#/components/schemas/${type}`
+        } }
+    }
+    if( type === 'int') type = 'integer';
+    if( type === 'bool') type = 'boolean';
+    return innerOnly ? { type, format, example:deflt } : { schema: { type, format, example:deflt } }
+
+}

package/src/lib/pathResolve.ts

@@ -0,0 +1,32 @@
+import path from "path";
+import fs from "fs";
+
+
+// Find the path roots in the project directory
+export function resolvePaths(
+) : {
+        basePath:string,  // project base
+        buildPath:string,  // build folder
+        functionPath:string, // functions folder
+        packagePath:string,  // package.json
+        verified:boolean // all of these exist if true, else, may be incomplete project
+    }
+{
+    const cwd = process.cwd()
+    let funcPath = path.join(cwd, 'functions')
+    while(true)
+    {
+        if(!fs.existsSync(funcPath))
+        {
+            funcPath = path.normalize(path.join(funcPath, ".."))
+        }
+        else
+        {
+            const basePath = path.normalize(path.join(funcPath, ".."))
+            const buildPath = path.join(basePath, "build");
+            const packagePath = path.join(basePath,"package.json");
+            const verified = fs.existsSync(basePath) && fs.existsSync(funcPath) && fs.existsSync(packagePath);
+            return {basePath, buildPath, functionPath:funcPath, packagePath, verified}
+        }
+    }
+}

package/src/lib/utils.ts

@@ -0,0 +1,45 @@
+import {executeCommand} from "./executeCommand";
+import * as ac from "ansi-colors";
+import * as fs from 'fs'
+
+/** General utilities */
+
+const zipDir = require('zip-dir')
+
+// pause the given number of milliseconds
+export async function delay(
+    ms:number // milliseconds to delay
+)
+{
+    return new Promise(resolve => {setTimeout(resolve, ms)})
+}
+
+export async function FolderToZip(
+    folderPath:string,
+    zipPath: string
+):Promise<Uint8Array>
+{
+    return new Promise(resolve => {
+        zipDir(folderPath, { saveTo: zipPath }, function (err:any, buffer:Uint8Array) {
+            if(err) throw err
+            // `buffer` is the buffer of the zipped file
+            // And the buffer was saved to `~/myzip.zip`
+            resolve(buffer);
+        })
+    })
+}
+export async function UnzipToFolder(
+    zipPath:string,
+    folderPath:string,
+    replace:boolean = true
+)
+{
+    // TODO: using CLI -- find a good package. "unzip" has vulnerabilities. Try others.
+
+    if(replace) fs.rmSync(folderPath, {recursive: true, force: true})
+    let result = await executeCommand('unzip', [zipPath,'-d', folderPath])
+    if (result.retcode) {
+        console.error(ac.red.bold(`failed to stage webroot (${result.retcode}): ${result.errStr}`));
+        throw Error();
+    }
+}

package/src/lift.ts

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+
+import * as ac from 'ansi-colors'
+import * as process from 'process'
+
+import {getLiftVersion} from "./lib/LiftVersion";
+
+import {doHelp} from "./commands/help"
+import {doInit} from "./commands/init"
+import {doCreate} from "./commands/create"
+import {doBuildAsync} from "./commands/build"
+import {doTestAsync} from "./commands/test"
+import {doPackageAsync} from "./commands/package"
+import {doDeployAsync} from "./commands/deploy";
+import {doPublishAsync} from "./commands/publish";
+import {doDoctor} from "./commands/doctor";
+import {startLocalServer} from "./commands/start";
+import {doSettings} from "./commands/settings";
+
+const command = process.argv[2] || 'help'
+const args = process.argv.slice(3)
+
+async function processCommand() {
+    switch (command) {
+        case 'version':
+        case '--version':
+        case '-v':
+            console.log(`Lift v${getLiftVersion()}`);
+            return;
+        case 'help':
+            return doHelp(args[0] ?? '')
+        case 'doctor':
+            return doDoctor();
+        case 'init':
+            return doInit(args[0] ?? '')
+        case 'create':
+            return doCreate(args[0] ?? '')
+        case 'build': {
+            const ret = await doBuildAsync ( args )
+            if (ret) process.exit( -1 )
+        }
+        return;
+        case 'test': {
+            const ret = await doTestAsync(args);
+            if (ret) process.exit(ret);
+        }
+        return;
+        case 'start':
+            return startLocalServer();
+
+        case 'package': {
+            const ret = await doPackageAsync(args);
+            if (ret) process.exit(ret);
+        }
+        return;
+        case 'deploy': {
+            const ret = await doDeployAsync(args);
+            if (ret) process.exit(ret);
+        }
+        return;
+        case 'publish': {
+            const ret = await doPublishAsync();
+            if (ret) process.exit(ret);
+        }
+        return;
+        case 'settings': {
+            const ret = await doSettings();
+            if (ret) process.exit(ret);
+        }
+        return;
+    }
+    return doUnknown(command)
+}
+
+function doUnknown(command:string) {
+    console.log(ac.red.bold(`Unrecognized command ${command || ''}`))
+    console.log(ac.grey.dim('try'))
+    console.log(ac.blue.dim('help, init, create, build, test, start, package, deploy, publish, settings'))
+    console.log('')
+}
+
+processCommand()

package/tsconfig.json

@@ -0,0 +1,28 @@
+{
+  "compilerOptions": {
+    "sourceMap": true,
+    "outDir": "./build",
+    "allowJs": true,
+    "target": "ES2015",                          /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', or 'ESNEXT'. */
+    "module": "commonjs",                     /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'. */
+    "lib": [
+      "dom",
+      "es2015",
+      "scripthost",
+      "es2015.proxy"
+    ],
+    /* Advanced Options */
+    "strict": true,                           /* Enable all strict type-checking options. */
+    "esModuleInterop": true,                  /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
+    "skipLibCheck": true,                     /* Skip type checking of declaration files. */
+    "forceConsistentCasingInFileNames": true  /* Disallow inconsistently-cased references to the same file. */
+  },
+  "exclude": [
+    "./node_modules/"
+  ],
+  "include": [
+    "**/*.ts",
+    "src/preload.js"
+  ]
+}
+