@tremho/mist-lift 1.1.2 → 1.1.4-pre-release.1

package/src/commands/actions/setupPackageJson.ts

@@ -1,32 +1,32 @@
-/** Adds necessary scripts to package.json */
-
-import * as path from 'path'
-import * as fs from 'fs'
-import { executeCommand } from '../../lib/executeCommand'
-
-/**
- * Adds necessary scripts to package.json
- */
-export function addPackageScripts (
-  projectPath: string
-): void {
-  const pkgPath = path.join(projectPath, 'package.json')
-  let pkgJson: any = {}
-  try { pkgJson = JSON.parse(fs.readFileSync(pkgPath).toString()) } catch {}
-  const script = pkgJson.script ?? {}
-  script.test = 'lift test'
-  pkgJson.script = script
-}
-export async function installPackage (
-  projectPath: string,
-  packageName: string
-): Promise<void> {
-  await executeCommand('npm', ['i', packageName], projectPath, true)
-}
-
-export async function installDevPackage (
-  projectPath: string,
-  packageName: string
-): Promise<void> {
-  await executeCommand('npm', ['i', '--save-dev', packageName], projectPath, true)
-}
+/** Adds necessary scripts to package.json */
+
+import * as path from 'path'
+import * as fs from 'fs'
+import { executeCommand } from '../../lib/executeCommand'
+
+/**
+ * Adds necessary scripts to package.json
+ */
+export function addPackageScripts (
+  projectPath: string
+): void {
+  const pkgPath = path.join(projectPath, 'package.json')
+  let pkgJson: any = {}
+  try { pkgJson = JSON.parse(fs.readFileSync(pkgPath).toString()) } catch {}
+  const script = pkgJson.script ?? {}
+  script.test = 'lift test'
+  pkgJson.script = script
+}
+export async function installPackage (
+  projectPath: string,
+  packageName: string
+): Promise<void> {
+  await executeCommand('npm', ['i', packageName], projectPath, true)
+}
+
+export async function installDevPackage (
+  projectPath: string,
+  packageName: string
+): Promise<void> {
+  await executeCommand('npm', ['i', '--save-dev', packageName], projectPath, true)
+}

package/src/commands/build.ts

@@ -1,170 +1,173 @@
-/** handles building in the project directory */
-
-import * as path from 'path'
-import * as fs from 'fs'
-import * as ac from 'ansi-colors'
-import { resolvePaths } from '../lib/pathResolve'
-import { recurseDirectory } from '../lib/DirectoryUtils'
-import { isNewer } from '../lib/fileCompare'
-import { executeCommand } from '../lib/executeCommand'
-import { mkdirSync } from 'fs'
-
-// Build command
-export async function doBuildAsync (
-  args: string[] // zero or more functions to build.  zero means build all
-): Promise<number> {
-  const projectPaths = resolvePaths()
-  if (!projectPaths.verified) {
-    console.log(ac.bold.magenta('current directory is not at project root'))
-    return -1
-  }
-  const funcsToBuild: string[] = []
-  const options: string[] = []
-  for (const arg of args) {
-    if (arg.charAt(0) === '-') {
-      options.push(arg.toLowerCase())
-    } else funcsToBuild.push(arg)
-  }
-
-  if (funcsToBuild.length === 0) {
-    let firstDepth = 0
-    recurseDirectory(projectPaths.functionPath, (filepath, stats) => {
-      const depth = filepath.split(path.sep).length
-      if (firstDepth === 0) firstDepth = depth
-      if (stats.isDirectory() && depth === firstDepth) {
-        funcsToBuild.push(path.basename(filepath))
-      }
-      return false
-    })
-  }
-
-  let failFast = options.includes('--failfast')
-  if (options.includes('--deferfail')) failFast = false
-
-  let fails = 0
-
-  for (const func of funcsToBuild) {
-    const funcDir = path.join(projectPaths.functionPath, func)
-    if (fs.existsSync(funcDir)) {
-      fails += await buildSingleFunction(funcDir, options)
-      if (fails > 0 && failFast) break
-    } else {
-      console.log(ac.red.bold(`${func} does not exist as a function`))
-      fails++
-      if (failFast) break
-    }
-  }
-  return fails
-}
-
-// build command for a single function
-async function buildSingleFunction (
-  funcDir: string,
-  options: string[]
-): Promise<number> {
-  const funcName = funcDir.substring(funcDir.lastIndexOf('/') + 1)
-  const buildPath = path.normalize(path.join(funcDir, '..', '..', 'build', 'functions', funcName))
-  if (options.includes('--clean')) {
-    if (fs.existsSync(buildPath)) {
-      fs.rmSync(buildPath, { recursive: true })
-    }
-  }
-  // strategy here is to invoke tsc on a per-folder basis rather than letting tsc do the recurse because it is easier to control this way
-  return await buildFunctionModules(funcName, funcDir, buildPath, options)
-}
-
-// build all the function modules in path
-async function buildFunctionModules (
-  funcName: string,
-  funcDir: string,
-  buildPath: string,
-  options: string[]
-): Promise<number> {
-  const announce = ac.blue.dim(`building ${funcName}...`)
-  let announced = false
-  let fails = 0
-  // let builds = 0
-  let failFast = options.includes('--failfast')
-  if (options.includes('--deferfail')) failFast = false
-  const all: Array<Promise<void>> = []
-  recurseDirectory(funcDir, (filepath, stats) => {
-    if (path.extname(filepath) === '.ts') {
-      let relPath = filepath.substring(funcDir.length)
-      relPath = relPath.substring(0, relPath.lastIndexOf('/'))
-      const outDir = path.join(buildPath, relPath)
-
-      if (!(fails > 0 && failFast)) {
-        if (isNewer(filepath, outDir)) {
-          if (!announced) {
-            announced = true
-            console.log(announce)
-          }
-          // builds++
-          all.push(executeCommand('tsc', [
-            '--esModuleInterop', 'true',
-            '--target', 'ES2015',
-            '--module', 'commonjs',
-            '--lib', 'dom,es2015,scripthost,es2015.proxy',
-            '--strict', 'true',
-            '--noImplicitAny', 'false',
-            '--skipLibCheck', 'true',
-            '--forceConsistentCasingInFileNames', 'true',
-            '--sourceMap', 'true',
-            '--outdir', outDir,
-            filepath
-          ], '', true).then((result: { retcode: number | undefined, stdOut: string, stdErr: string }) => {
-            if (result.retcode !== 0) {
-              fails++
-              // console.log("error detected", fails)
-              const now = new Date()
-              fs.utimesSync(filepath, now, now) // touch file so it is not skipped next build
-            }
-          }))
-        }
-      }
-    }
-    fails += doPostBuildSteps(funcDir, buildPath)
-    return false
-  })
-  return await Promise.all(all).then(async () => {
-    return fails
-  })
-}
-
-// do the steps after the build (file copies, etc)
-function doPostBuildSteps (
-  funcDir: string,
-  buildPath: string
-): number {
-  // copy the definitions,json file over
-  const srcdef = path.join(funcDir, 'src', 'definition.json')
-  const dstdef = path.join(buildPath, 'src', 'definition.json')
-  if (fs.existsSync(srcdef)) {
-    const destFolder = path.dirname(dstdef)
-    if (!fs.existsSync((destFolder))) mkdirSync(destFolder, { recursive: true })
-    fs.copyFileSync(srcdef, dstdef)
-  } else {
-    console.error(ac.red.bold('no definition file found at ' + srcdef))
-    return 1
-  }
-  // copy the resources folder if it exists
-  const filedirPath = path.join(funcDir, 'resources')
-  if (fs.existsSync(filedirPath)) {
-    const bfiles = path.join(buildPath, 'resources')
-    if (!fs.existsSync(bfiles)) fs.mkdirSync(bfiles, { recursive: true })
-    recurseDirectory(filedirPath, (filepath, stats) => {
-      let relPath = filepath.substring(funcDir.length)
-      relPath = relPath.substring(0, relPath.lastIndexOf('/'))
-      const outDir = path.join(buildPath, relPath)
-      const target = path.join(outDir, path.basename(filepath))
-      if (stats.isDirectory() && !fs.existsSync(target)) {
-        fs.mkdirSync(target, { recursive: true })
-      }
-      if (stats.isFile()) {
-        fs.copyFileSync(filepath, target)
-      }
-      return false
-    })
-  }
-  return 0
-}
+/** handles building in the project directory */
+
+import * as path from 'path'
+import * as fs from 'fs'
+import * as ac from 'ansi-colors'
+import { resolvePaths } from '../lib/pathResolve'
+import { recurseDirectory } from '../lib/DirectoryUtils'
+import { isNewer } from '../lib/fileCompare'
+import { executeCommand } from '../lib/executeCommand'
+import { mkdirSync } from 'fs'
+
+let projectPaths:any = {}
+
+// Build command
+export async function doBuildAsync (
+  args: string[] // zero or more functions to build.  zero means build all
+): Promise<number> {
+  projectPaths = resolvePaths();
+  if (!projectPaths.verified) {
+    console.log(ac.bold.magenta('current directory is not at project root'))
+    return -1
+  }
+  const funcsToBuild: string[] = []
+  const options: string[] = []
+  for (const arg of args) {
+    if (arg.charAt(0) === '-') {
+      options.push(arg.toLowerCase())
+    } else funcsToBuild.push(arg)
+  }
+
+  if (funcsToBuild.length === 0) {
+    let firstDepth = 0
+    recurseDirectory(projectPaths.functionPath, (filepath, stats) => {
+      const depth = filepath.split(path.sep).length
+      if (firstDepth === 0) firstDepth = depth
+      if (stats.isDirectory() && depth === firstDepth) {
+        funcsToBuild.push(path.basename(filepath))
+      }
+      return false
+    })
+  }
+
+  let failFast = options.includes('--failfast')
+  if (options.includes('--deferfail')) failFast = false
+
+  let fails = 0
+
+  for (const func of funcsToBuild) {
+    const funcDir = path.join(projectPaths.functionPath, func)
+    if (fs.existsSync(funcDir)) {
+      fails += await buildSingleFunction(funcDir, options)
+      if (fails > 0 && failFast) break
+    } else {
+      console.log(ac.red.bold(`${func} does not exist as a function`))
+      fails++
+      if (failFast) break
+    }
+  }
+  return fails
+}
+
+// build command for a single function
+async function buildSingleFunction (
+  funcDir: string,
+  options: string[]
+): Promise<number> {
+  const funcName = funcDir.substring(funcDir.lastIndexOf(path.sep) + 1)
+  const buildPath = path.join(projectPaths.basePath, 'build', 'functions', funcName)
+
+  if (options.includes('--clean')) {
+    if (fs.existsSync(buildPath)) {
+      fs.rmSync(buildPath, { recursive: true })
+    }
+  }
+  // strategy here is to invoke tsc on a per-folder basis rather than letting tsc do the recurse because it is easier to control this way
+  return await buildFunctionModules(funcName, funcDir, buildPath, options)
+}
+
+// build all the function modules in path
+async function buildFunctionModules (
+  funcName: string,
+  funcDir: string,
+  buildPath: string,
+  options: string[]
+): Promise<number> {
+  const announce = ac.blue.dim(`building ${funcName}...`)
+  let announced = false
+  let fails = 0
+  // let builds = 0
+  let failFast = options.includes('--failfast')
+  if (options.includes('--deferfail')) failFast = false
+  const all: Array<Promise<void>> = []
+  recurseDirectory(funcDir, (filepath, stats) => {
+    if (path.extname(filepath) === '.ts') {
+      let relPath = filepath.substring(funcDir.length)
+      relPath = relPath.substring(0, relPath.lastIndexOf(path.sep))
+      const outDir = path.join(buildPath, relPath)
+
+      if (!(fails > 0 && failFast)) {
+        if (isNewer(filepath, outDir)) {
+          if (!announced) {
+            announced = true
+            console.log(announce)
+          }
+          // builds++
+          all.push(executeCommand('tsc', [
+            '--esModuleInterop', 'true',
+            '--target', 'ES2015',
+            '--module', 'commonjs',
+            '--lib', 'dom,es2015,scripthost,es2015.proxy',
+            '--strict', 'true',
+            '--noImplicitAny', 'false',
+            '--skipLibCheck', 'true',
+            '--forceConsistentCasingInFileNames', 'true',
+            '--sourceMap', 'true',
+            '--outdir', outDir,
+            filepath
+          ], '', true).then((result: { retcode: number | undefined, stdOut: string, stdErr: string }) => {
+            if (result.retcode !== 0) {
+              fails++
+              // console.log("error detected", fails)
+              const now = new Date()
+              fs.utimesSync(filepath, now, now) // touch file so it is not skipped next build
+            }
+          }))
+        }
+      }
+    }
+    fails += doPostBuildSteps(funcDir, buildPath)
+    return false
+  })
+  return await Promise.all(all).then(async () => {
+    return fails
+  })
+}
+
+// do the steps after the build (file copies, etc)
+function doPostBuildSteps (
+  funcDir: string,
+  buildPath: string
+): number {
+  // copy the definitions,json file over
+  const srcdef = path.join(funcDir, 'src', 'definition.json')
+  const dstdef = path.join(buildPath, 'src', 'definition.json')
+  if (fs.existsSync(srcdef)) {
+    const destFolder = path.dirname(dstdef)
+    if (!fs.existsSync(destFolder)) mkdirSync(destFolder, { recursive: true })
+    fs.copyFileSync(srcdef, dstdef)
+  } else {
+    console.error(ac.red.bold('no definition file found at ' + srcdef))
+    return 1
+  }
+  // copy the resources folder if it exists
+  const filedirPath = path.join(funcDir, 'resources')
+  if (fs.existsSync(filedirPath)) {
+    const bfiles = path.join(buildPath, 'resources')
+    if (!fs.existsSync(bfiles)) fs.mkdirSync(bfiles, { recursive: true })
+    recurseDirectory(filedirPath, (filepath, stats) => {
+      let relPath = filepath.substring(funcDir.length)
+      relPath = relPath.substring(0, relPath.lastIndexOf(path.sep))
+      const outDir = path.join(buildPath, relPath)
+      const target = path.join(outDir, path.basename(filepath))
+      if (stats.isDirectory() && !fs.existsSync(target)) {
+        fs.mkdirSync(target, { recursive: true })
+      }
+      if (stats.isFile()) {
+        fs.copyFileSync(filepath, target)
+      }
+      return false
+    })
+  }
+  return 0
+}

package/src/commands/builtin/ApiDocMaker.ts

@@ -1,102 +1,106 @@
-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)
-}
-
-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[]): 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
-  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 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' }
-  }
-}
+import { gatherFunctionDefinitions } from '../../lib/openAPI/ApiBuildCollector'
+import { buildOpenApi } from '../../lib/openAPI/openApiConstruction'
+import { GetWebrootServePaths } from '../../lib/openAPI/WebrootFileSupport'
+
+import path from 'path'
+
+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[]): 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
+  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
+      let rootPath = root.replace(path.sep, '/');
+      while (rootName.includes(path.sep)) rootName = rootName.replace(path.sep, '').toLowerCase().trim()
+      console.log("$$$$>> rootPath, rootName", rootPath, rootName)
+      const fileserve = Object.assign({}, fileServeDef) // copy
+      fileserve.name = 'fileserve_' + rootName
+      fileserve.pathMap = `${rootPath}/{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' }
+  }
+}