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

package/src/commands/builtin/ApiDocMaker.ts

@@ -1,70 +1,102 @@
-import {gatherFunctionDefinitions} from "../../lib/openAPI/ApiBuildCollector";
-import {buildOpenApi} from "../../lib/openAPI/openApiConstruction";
-import {whiteBright} from "ansi-colors";
-import {GetWebrootServePaths} from "../../lib/openAPI/WebrootFileSupport";
+import { gatherFunctionDefinitions } from '../../lib/openAPI/ApiBuildCollector'
+import { buildOpenApi } from '../../lib/openAPI/openApiConstruction'
+import { GetWebrootServePaths } from '../../lib/openAPI/WebrootFileSupport'
 
 export async function MakePublicApiDoc
 (
-):Promise<Uint8Array>
-{
-    const defs = gatherFunctionDefinitions();
-    return await buildOpenApi(defs)
+): Promise<Uint8Array> {
+  const defs = gatherFunctionDefinitions()
+  return await buildOpenApi(defs)
 }
 
 export async function MakeBuiltinApiDoc
 (
-    yamlFile:string
+  yamlFile: string
 
-):Promise<Uint8Array>
-{
-    const defs = gatherFunctionDefinitions()
-    addBuiltInDefinitions(defs)
-    return await buildOpenApi(defs, false, yamlFile) //, true)
+): 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);
+export function addBuiltInDefinitions (defs: any[]): void {
+  // 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);
-        }
+  // console.warn("Adding webroot literals");
+  // do just /docs and see how that goes
+  const fsdef = Object.assign({}, fileServeDef) // copy
+  fsdef.name = 'fileserve_docs'
+  fsdef.pathMap = '/docs/{path}'
+  defs.push(fsdef)
+  const roots = GetWebrootServePaths()
+  // console.log("roots", roots)
+  for (const root of roots) {
+    if (root !== '') {
+      let rootName = root
+      while (rootName.includes('/')) rootName = rootName.replace('/', '').toLowerCase().trim()
+      const 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 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 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"}}}
+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

@@ -1,51 +1,47 @@
-import {StageWebrootZip} from "./StageWebrootZip";
-import {DeployBuiltInZip} from "./DeployBuiltInZip";
-import {GetWebrootServePaths} from "../../lib/openAPI/WebrootFileSupport";
+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});
+): Promise<void> {
+  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))
+): Promise<void> {
+  // 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')
+  const all: Array<Promise<any>> = []
+  for (let root of roots) {
+    root = root.trim()
+    let name = 'fileserve_' + root
+    while (name.includes('/')) {
+      name = name.replace('/', '')
     }
-    // console.log('wait all');
-    await Promise.all(all);
-    // console.log('all complete');
+    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)
+): 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

@@ -1,27 +1,25 @@
 
 import * as path from 'path'
-import {deployPackage} from '../deploy'
+import { deployPackage } from '../deploy'
 
 export async function DeployBuiltInZip
 (
-    name:string,
-    zipPath:string
-)
-{
-    // console.log(">> Deploying "+name)
-    await deployPackage(name, zipPath);
+  name: string,
+  zipPath: string
+): Promise<void> {
+  // 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)
-    }
+  root: string
+): Promise<void> {
+  // rootName is without slash
+  if (root !== '') {
+    const rootName = root.replace('/', '')
+    const name = 'fileserve_' + rootName
+    const zipPath = path.join(__dirname, 'prebuilt-zips', 'FileServe.zip')
+    await DeployBuiltInZip(name, zipPath)
+  }
 }

package/src/commands/builtin/StageWebrootZip.ts

@@ -1,39 +1,36 @@
-import {MakePublicApiDoc} from "./ApiDocMaker";
+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";
+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')
+): 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)
+    }
+    return false
+  })
+  const webrootZip = path.join(projectPaths.basePath, 'a.zip')
 
-    await FolderToZip(path.join(packageTemp, 'Webroot'), webrootZip)
-    // return path to this zip
-    return webrootZip
-
-}
+  await FolderToZip(path.join(packageTemp, 'Webroot'), webrootZip)
+  // return path to this zip
+  return webrootZip
+}

package/src/commands/create.ts

@@ -2,54 +2,47 @@
 
 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";
-
+import * as ac from 'ansi-colors'
+import { resolvePaths } from '../lib/pathResolve'
+import { camelCase } 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'));
-
+export function doCreate (
+  funcName?: string // name of function to create
+): void {
+  if (funcName === '' || funcName === undefined) {
+    helpCreate()
+  } 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.includes('$$FUNCTION_NAME$$')) {
+      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.includes('$$FUNCTION_NAME$$')) {
+      defsrc = defsrc.replace('$$FUNCTION_NAME$$', funcName)
+    }
+    const 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.includes('$$TemplateName$$')) {
+      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'))
+  }
 }
-