@budibase/cli 0.0.1

package/src/plugins/skeleton.ts

@@ -0,0 +1,65 @@
+import fetch from "node-fetch"
+import fs from "fs"
+import os from "os"
+import { join } from "path"
+import { processStringSync } from "@budibase/string-templates"
+const download = require("download")
+const tar = require("tar")
+
+const HBS_FILES = ["package.json.hbs", "schema.json.hbs", "README.md.hbs"]
+
+async function getSkeletonUrl(type: string) {
+  const resp = await fetch(
+    "https://api.github.com/repos/budibase/budibase-skeleton/releases/latest"
+  )
+  if (resp.status >= 300) {
+    throw new Error("Failed to retrieve skeleton metadata")
+  }
+  const json = (await resp.json()) as { assets: any[] }
+  for (let asset of json["assets"]) {
+    if (asset.name && asset.name.includes(type)) {
+      return asset["browser_download_url"]
+    }
+  }
+  throw new Error("No skeleton found in latest release.")
+}
+
+export async function getSkeleton(type: string, name: string) {
+  const url = await getSkeletonUrl(type)
+  const tarballFile = join(os.tmpdir(), "skeleton.tar.gz")
+
+  // download the full skeleton tarball
+  fs.writeFileSync(tarballFile, await download(url))
+  fs.mkdirSync(name)
+  // extract it and get what we need
+  await tar.extract({
+    file: tarballFile,
+    C: name,
+  })
+  // clear up
+  fs.rmSync(tarballFile)
+}
+
+export async function fleshOutSkeleton(
+  type: string,
+  name: string,
+  description: string,
+  version: string
+) {
+  for (let file of HBS_FILES) {
+    const oldFile = join(name, file),
+      newFile = join(name, file.substring(0, file.length - 4))
+    const hbsContents = fs.readFileSync(oldFile, "utf8")
+    if (!hbsContents) {
+      continue
+    }
+    const output = processStringSync(hbsContents, {
+      name,
+      description,
+      version,
+    })
+    // write the updated file and remove the HBS file
+    fs.writeFileSync(newFile, output)
+    fs.rmSync(oldFile)
+  }
+}

package/src/prebuilds.ts

@@ -0,0 +1,50 @@
+import os from "os"
+import { join } from "path"
+import fs from "fs"
+import { error } from "./utils"
+
+const PREBUILDS = "prebuilds"
+const ARCH = `${os.platform()}-${os.arch()}`
+const PREBUILD_DIR = join(process.execPath, "..", PREBUILDS, ARCH)
+
+// running as built CLI pkg bundle
+if (!process.argv[0].includes("node")) {
+  checkForBinaries()
+}
+
+function checkForBinaries() {
+  const readDir = join(__filename, "..", "..", PREBUILDS, ARCH)
+  if (fs.existsSync(PREBUILD_DIR) || !fs.existsSync(readDir)) {
+    return
+  }
+  const natives = fs.readdirSync(readDir)
+  if (fs.existsSync(readDir)) {
+    fs.mkdirSync(PREBUILD_DIR, { recursive: true })
+    for (let native of natives) {
+      const filename = `${native.split(".fake")[0]}.node`
+      fs.cpSync(join(readDir, native), join(PREBUILD_DIR, filename))
+    }
+  }
+}
+
+function cleanup(evt?: number) {
+  if (evt && !isNaN(evt)) {
+    return
+  }
+  if (evt) {
+    console.error(
+      error(
+        "Failed to run CLI command - please report with the following message:"
+      )
+    )
+    console.error(error(evt))
+  }
+  if (fs.existsSync(PREBUILD_DIR)) {
+    fs.rmSync(PREBUILD_DIR, { recursive: true })
+  }
+}
+
+const events = ["exit", "SIGINT", "SIGUSR1", "SIGUSR2", "uncaughtException"]
+events.forEach(event => {
+  process.on(event, cleanup)
+})

package/src/questions.ts

@@ -0,0 +1,40 @@
+const inquirer = require("inquirer")
+
+export async function confirmation(question: string) {
+  const config = {
+    type: "confirm",
+    message: question,
+    default: true,
+    name: "confirmation",
+  }
+  return (await inquirer.prompt(config)).confirmation
+}
+
+export async function string(question: string, defaultString?: string) {
+  const config: any = {
+    type: "input",
+    name: "string",
+    message: question,
+  }
+  if (defaultString) {
+    config.default = defaultString
+  }
+  return (await inquirer.prompt(config)).string
+}
+
+export async function number(question: string, defaultNumber?: number) {
+  const config: any = {
+    type: "input",
+    name: "number",
+    message: question,
+    validate: (value: string) => {
+      let valid = !isNaN(parseFloat(value))
+      return valid || "Please enter a number"
+    },
+    filter: Number,
+  }
+  if (defaultNumber) {
+    config.default = defaultNumber
+  }
+  return (await inquirer.prompt(config)).number
+}

package/src/structures/Command.ts

@@ -0,0 +1,94 @@
+import {
+  getSubHelpDescription,
+  getHelpDescription,
+  error,
+  capitaliseFirstLetter,
+} from "../utils"
+
+type CommandOpt = {
+  command: string
+  help: string
+  func?: Function
+  extras: any[]
+}
+
+export class Command {
+  command: string
+  opts: CommandOpt[]
+  func?: Function
+  help?: string
+
+  constructor(command: string, func?: Function) {
+    // if there are options, need to just get the command name
+    this.command = command
+    this.opts = []
+    this.func = func
+  }
+
+  convertToCommander(lookup: string) {
+    const parts = lookup.toLowerCase().split("-")
+    // camel case, separate out first
+    const first = parts.shift()
+    return [first]
+      .concat(parts.map(part => capitaliseFirstLetter(part)))
+      .join("")
+  }
+
+  addHelp(help: string) {
+    this.help = help
+    return this
+  }
+
+  addSubOption(
+    command: string,
+    help: string,
+    func?: Function,
+    extras: any[] = []
+  ) {
+    this.opts.push({ command, help, func, extras })
+    return this
+  }
+
+  configure(program: any) {
+    const thisCmd = this
+    let command = program.command(thisCmd.command)
+    if (this.help) {
+      command = command.description(getHelpDescription(thisCmd.help!))
+    }
+    for (let opt of thisCmd.opts) {
+      command = command.option(opt.command, getSubHelpDescription(opt.help))
+    }
+    command.helpOption(
+      "--help",
+      getSubHelpDescription(`Get help with ${this.command} options`)
+    )
+    command.action(async (options: Record<string, string>) => {
+      try {
+        let executed = false,
+          found = false
+        for (let opt of thisCmd.opts) {
+          let lookup = opt.command.split(" ")[0].replace("--", "")
+          // need to handle how commander converts watch-plugin-dir to watchPluginDir
+          lookup = this.convertToCommander(lookup)
+          found = !executed && !!options[lookup]
+          if (found && opt.func) {
+            const input =
+              Object.keys(options).length > 1 ? options : options[lookup]
+            await opt.func(input)
+            executed = true
+          }
+        }
+        if (found && !executed) {
+          console.log(
+            error(`${Object.keys(options)[0]} is an option, not an operation.`)
+          )
+        } else if (!executed) {
+          console.log(error(`Unknown ${this.command} option.`))
+          command.help()
+        }
+      } catch (err: any) {
+        console.log(error(err))
+      }
+    })
+  }
+}

package/src/structures/ConfigManager.ts

@@ -0,0 +1,49 @@
+const fs = require("fs")
+const path = require("path")
+const os = require("os")
+const { error } = require("../utils")
+
+export class ConfigManager {
+  path: string
+
+  constructor() {
+    this.path = path.join(os.homedir(), ".budibase.json")
+    if (!fs.existsSync(this.path)) {
+      fs.writeFileSync(this.path, "{}")
+    }
+  }
+
+  get config() {
+    try {
+      return JSON.parse(fs.readFileSync(this.path, "utf8"))
+    } catch (err) {
+      console.log(
+        error(
+          "Error parsing configuration file. Please check your .budibase.json is valid."
+        )
+      )
+      return {}
+    }
+  }
+
+  set config(json: any) {
+    fs.writeFileSync(this.path, JSON.stringify(json))
+  }
+
+  getValue(key: string) {
+    return this.config[key]
+  }
+
+  setValue(key: string, value: any) {
+    this.config = {
+      ...this.config,
+      [key]: value,
+    }
+  }
+
+  removeKey(key: string) {
+    const updated = { ...this.config }
+    delete updated[key]
+    this.config = updated
+  }
+}

package/src/utils.ts

@@ -0,0 +1,112 @@
+import chalk from "chalk"
+import fs from "fs"
+import path from "path"
+import { join } from "path"
+import fetch from "node-fetch"
+const progress = require("cli-progress")
+
+export function downloadFile(url: string, filePath: string) {
+  return new Promise((resolve, reject) => {
+    filePath = path.resolve(filePath)
+    fetch(url, {
+      method: "GET",
+    })
+      .then(response => {
+        const writer = fs.createWriteStream(filePath)
+        if (response.body) {
+          response.body.pipe(writer)
+          response.body.on("end", resolve)
+          response.body.on("error", reject)
+        } else {
+          throw new Error(
+            `Unable to retrieve docker-compose file - ${response.status}`
+          )
+        }
+      })
+      .catch(err => {
+        throw err
+      })
+  })
+}
+
+export async function httpCall(url: string, method: string) {
+  const response = await fetch(url, {
+    method,
+  })
+  return response.body
+}
+
+export function getHelpDescription(str: string) {
+  return chalk.cyan(str)
+}
+
+export function getSubHelpDescription(str: string) {
+  return chalk.green(str)
+}
+
+export function error(err: string | number) {
+  process.exitCode = -1
+  return chalk.red(`Error - ${err}`)
+}
+
+export function success(str: string) {
+  return chalk.green(str)
+}
+
+export function info(str: string) {
+  return chalk.cyan(str)
+}
+
+export function logErrorToFile(file: string, error: string) {
+  fs.writeFileSync(path.resolve(`./${file}`), `Budibase Error\n${error}`)
+}
+
+export function parseEnv(env: string) {
+  const lines = env.toString().split("\n")
+  let result: Record<string, string> = {}
+  for (const line of lines) {
+    const match = line.match(/^([^=:#]+?)[=:](.*)/)
+    if (match) {
+      result[match[1].trim()] = match[2].trim()
+    }
+  }
+  return result
+}
+
+export function progressBar(total: number) {
+  const bar = new progress.SingleBar({}, progress.Presets.shades_classic)
+  bar.start(total, 0)
+  return bar
+}
+
+export function checkSlashesInUrl(url: string) {
+  return url.replace(/(https?:\/\/)|(\/)+/g, "$1$2")
+}
+
+export function moveDirectory(oldPath: string, newPath: string) {
+  const files = fs.readdirSync(oldPath)
+  // check any file exists already
+  for (let file of files) {
+    if (fs.existsSync(join(newPath, file))) {
+      throw new Error(
+        "Unable to remove top level directory - some skeleton files already exist."
+      )
+    }
+  }
+  for (let file of files) {
+    fs.renameSync(join(oldPath, file), join(newPath, file))
+  }
+  fs.rmdirSync(oldPath)
+}
+
+export function capitaliseFirstLetter(str: string) {
+  return str.charAt(0).toUpperCase() + str.slice(1)
+}
+
+export function stringifyToDotEnv(json: Record<string, string | number>) {
+  let str = ""
+  for (let [key, value] of Object.entries(json)) {
+    str += `${key}=${value}\n`
+  }
+  return str
+}

package/start.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+dir="$(dirname -- "$(readlink -f "${BASH_SOURCE}")")"
+${dir}/node_modules/ts-node/dist/bin.js ${dir}/src/index.ts $@

package/tsconfig.build.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "target": "es6",
+    "module": "commonjs",
+    "lib": ["es2020"],
+    "strict": true,
+    "noImplicitAny": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "incremental": true,
+    "types": [ "node", "jest" ],
+    "outDir": "dist",
+    "skipLibCheck": true
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "**/*.spec.ts",
+    "**/*.spec.js"
+  ]
+}

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "extends": "./tsconfig.build.json",
+  "compilerOptions": {
+    "composite": true,
+    "declaration": true,
+    "sourceMap": true,
+    "baseUrl": ".",
+    "paths": {
+      "@budibase/types": ["../types/src"],
+      "@budibase/backend-core": ["../backend-core/src"],
+      "@budibase/backend-core/*": ["../backend-core/*"]
+    }
+  },
+  "ts-node": {
+    "require": ["tsconfig-paths/register"],
+    "swc": true
+  },
+
+  "include": ["src/**/*", "package.json"],
+  "exclude": ["node_modules", "dist"]
+}