@budibase/cli 2.3.19 → 2.3.21-alpha.0

package/dist/plugins/index.js

@@ -0,0 +1,199 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Command_1 = require("../structures/Command");
+const constants_1 = require("../constants");
+const skeleton_1 = require("./skeleton");
+const questions = __importStar(require("../questions"));
+const fs_1 = __importDefault(require("fs"));
+const types_1 = require("@budibase/types");
+const backend_core_1 = require("@budibase/backend-core");
+const exec_1 = require("../exec");
+const path_1 = require("path");
+const utils_1 = require("../utils");
+const events_1 = require("../events");
+const constants_2 = require("../constants");
+const init_1 = require("../hosting/init");
+const start_1 = require("../hosting/start");
+const fp = require("find-free-port");
+function checkInPlugin() {
+    if (!fs_1.default.existsSync("package.json")) {
+        throw new Error("Please run in a plugin directory - must contain package.json");
+    }
+    if (!fs_1.default.existsSync("schema.json")) {
+        throw new Error("Please run in a plugin directory - must contain schema.json");
+    }
+}
+function askAboutTopLevel(name) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const files = fs_1.default.readdirSync(process.cwd());
+        // we are in an empty git repo, don't ask
+        if (files.find(file => file === ".git")) {
+            return false;
+        }
+        else {
+            console.log((0, utils_1.info)(`By default the plugin will be created in the directory "${name}"`));
+            console.log((0, utils_1.info)("if you are already in an empty directory, such as a new Git repo, you can disable this functionality."));
+            return questions.confirmation("Create top level directory?");
+        }
+    });
+}
+function init(opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const type = opts["init"] || opts;
+        if (!type || !types_1.PLUGIN_TYPE_ARR.includes(type)) {
+            console.log((0, utils_1.error)("Please provide a type to init, either 'component' or 'datasource'."));
+            return;
+        }
+        console.log((0, utils_1.info)("Lets get some details about your new plugin:"));
+        const name = yield questions.string("Name", `budibase-${type}`);
+        if (fs_1.default.existsSync(name)) {
+            console.log((0, utils_1.error)("Directory by plugin name already exists, pick a new name."));
+            return;
+        }
+        const description = yield questions.string("Description", `An amazing Budibase ${type}!`);
+        const version = yield questions.string("Version", "1.0.0");
+        const topLevel = yield askAboutTopLevel(name);
+        // get the skeleton
+        console.log((0, utils_1.info)("Retrieving project..."));
+        yield (0, skeleton_1.getSkeleton)(type, name);
+        yield (0, skeleton_1.fleshOutSkeleton)(type, name, description, version);
+        console.log((0, utils_1.info)("Installing dependencies..."));
+        yield (0, exec_1.runPkgCommand)("install", (0, path_1.join)(process.cwd(), name));
+        // if no parent directory desired move to cwd
+        if (!topLevel) {
+            (0, utils_1.moveDirectory)(name, process.cwd());
+            console.log((0, utils_1.info)(`Plugin created in current directory.`));
+        }
+        else {
+            console.log((0, utils_1.info)(`Plugin created in directory "${name}"`));
+        }
+        (0, events_1.captureEvent)(constants_1.AnalyticsEvent.PluginInit, {
+            type,
+            name,
+            description,
+            version,
+        });
+    });
+}
+function verify() {
+    return __awaiter(this, void 0, void 0, function* () {
+        // will throw errors if not acceptable
+        checkInPlugin();
+        console.log((0, utils_1.info)("Verifying plugin..."));
+        const schema = fs_1.default.readFileSync("schema.json", "utf8");
+        const pkg = fs_1.default.readFileSync("package.json", "utf8");
+        let name, version;
+        try {
+            const schemaJson = JSON.parse(schema);
+            const pkgJson = JSON.parse(pkg);
+            if (!pkgJson.name || !pkgJson.version || !pkgJson.description) {
+                throw new Error("package.json is missing one of 'name', 'version' or 'description'.");
+            }
+            name = pkgJson.name;
+            version = pkgJson.version;
+            backend_core_1.plugins.validate(schemaJson);
+            return { name, version };
+        }
+        catch (err) {
+            if (err && err.message && err.message.includes("not valid JSON")) {
+                console.log((0, utils_1.error)(`schema.json is not valid JSON: ${err.message}`));
+            }
+            else {
+                console.log((0, utils_1.error)(`Invalid schema/package.json: ${err.message}`));
+            }
+        }
+    });
+}
+function build() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const verified = yield verify();
+        if (!(verified === null || verified === void 0 ? void 0 : verified.name)) {
+            return;
+        }
+        console.log((0, utils_1.success)("Verified!"));
+        console.log((0, utils_1.info)("Building plugin..."));
+        yield (0, exec_1.runPkgCommand)("build");
+        const output = (0, path_1.join)("dist", `${verified.name}-${verified.version}.tar.gz`);
+        console.log((0, utils_1.success)(`Build complete - output in: ${output}`));
+    });
+}
+function watch() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const verified = yield verify();
+        if (!(verified === null || verified === void 0 ? void 0 : verified.name)) {
+            return;
+        }
+        const output = (0, path_1.join)("dist", `${verified.name}-${verified.version}.tar.gz`);
+        console.log((0, utils_1.info)(`Watching - build in: ${output}`));
+        try {
+            yield (0, exec_1.runPkgCommand)("watch");
+        }
+        catch (err) {
+            // always errors when user escapes
+            console.log((0, utils_1.success)("Watch exited."));
+        }
+    });
+}
+function dev() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const pluginDir = yield questions.string("Directory to watch", "./");
+        const [port] = yield fp(10000);
+        const password = "admin";
+        yield (0, init_1.init)({
+            init: constants_1.InitType.QUICK,
+            single: true,
+            watchPluginDir: pluginDir,
+            genUser: password,
+            port,
+            silent: true,
+        });
+        yield (0, start_1.start)();
+        console.log((0, utils_1.success)(`Configuration has been written to docker-compose.yaml`));
+        console.log((0, utils_1.success)("Development environment started successfully - connect at: ") +
+            (0, utils_1.info)(`http://localhost:${port}`));
+        console.log((0, utils_1.success)("Use the following credentials to login:"));
+        console.log((0, utils_1.success)("Email: ") + (0, utils_1.info)(constants_2.GENERATED_USER_EMAIL));
+        console.log((0, utils_1.success)("Password: ") + (0, utils_1.info)(password));
+    });
+}
+exports.default = new Command_1.Command(`${constants_1.CommandWord.PLUGIN}`)
+    .addHelp("Custom plugins for Budibase, init, build and verify your components and datasources with this tool.")
+    .addSubOption("--init [type]", "Init a new plugin project, with a type of either component or datasource.", init)
+    .addSubOption("--build", "Build your plugin, this will verify and produce a final tarball for your project.", build)
+    .addSubOption("--watch", "Automatically build any changes to your plugin.", watch)
+    .addSubOption("--dev", "Run a development environment which automatically watches the current directory.", dev);

package/dist/plugins/skeleton.js

@@ -0,0 +1,75 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fleshOutSkeleton = exports.getSkeleton = void 0;
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = require("path");
+const string_templates_1 = require("@budibase/string-templates");
+const download = require("download");
+const tar = require("tar");
+const HBS_FILES = ["package.json.hbs", "schema.json.hbs", "README.md.hbs"];
+function getSkeletonUrl(type) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const resp = yield (0, node_fetch_1.default)("https://api.github.com/repos/budibase/budibase-skeleton/releases/latest");
+        if (resp.status >= 300) {
+            throw new Error("Failed to retrieve skeleton metadata");
+        }
+        const json = (yield resp.json());
+        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.");
+    });
+}
+function getSkeleton(type, name) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const url = yield getSkeletonUrl(type);
+        const tarballFile = (0, path_1.join)(os_1.default.tmpdir(), "skeleton.tar.gz");
+        // download the full skeleton tarball
+        fs_1.default.writeFileSync(tarballFile, yield download(url));
+        fs_1.default.mkdirSync(name);
+        // extract it and get what we need
+        yield tar.extract({
+            file: tarballFile,
+            C: name,
+        });
+        // clear up
+        fs_1.default.rmSync(tarballFile);
+    });
+}
+exports.getSkeleton = getSkeleton;
+function fleshOutSkeleton(type, name, description, version) {
+    return __awaiter(this, void 0, void 0, function* () {
+        for (let file of HBS_FILES) {
+            const oldFile = (0, path_1.join)(name, file), newFile = (0, path_1.join)(name, file.substring(0, file.length - 4));
+            const hbsContents = fs_1.default.readFileSync(oldFile, "utf8");
+            if (!hbsContents) {
+                continue;
+            }
+            const output = (0, string_templates_1.processStringSync)(hbsContents, {
+                name,
+                description,
+                version,
+            });
+            // write the updated file and remove the HBS file
+            fs_1.default.writeFileSync(newFile, output);
+            fs_1.default.rmSync(oldFile);
+        }
+    });
+}
+exports.fleshOutSkeleton = fleshOutSkeleton;

package/dist/prebuilds.js

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

package/dist/questions.js

@@ -0,0 +1,58 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.number = exports.string = exports.confirmation = void 0;
+const inquirer = require("inquirer");
+function confirmation(question) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const config = {
+            type: "confirm",
+            message: question,
+            default: true,
+            name: "confirmation",
+        };
+        return (yield inquirer.prompt(config)).confirmation;
+    });
+}
+exports.confirmation = confirmation;
+function string(question, defaultString) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const config = {
+            type: "input",
+            name: "string",
+            message: question,
+        };
+        if (defaultString) {
+            config.default = defaultString;
+        }
+        return (yield inquirer.prompt(config)).string;
+    });
+}
+exports.string = string;
+function number(question, defaultNumber) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const config = {
+            type: "input",
+            name: "number",
+            message: question,
+            validate: (value) => {
+                let valid = !isNaN(parseFloat(value));
+                return valid || "Please enter a number";
+            },
+            filter: Number,
+        };
+        if (defaultNumber) {
+            config.default = defaultNumber;
+        }
+        return (yield inquirer.prompt(config)).number;
+    });
+}
+exports.number = number;

package/dist/structures/Command.js

@@ -0,0 +1,75 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Command = void 0;
+const utils_1 = require("../utils");
+class Command {
+    constructor(command, func) {
+        // if there are options, need to just get the command name
+        this.command = command;
+        this.opts = [];
+        this.func = func;
+    }
+    convertToCommander(lookup) {
+        const parts = lookup.toLowerCase().split("-");
+        // camel case, separate out first
+        const first = parts.shift();
+        return [first]
+            .concat(parts.map(part => (0, utils_1.capitaliseFirstLetter)(part)))
+            .join("");
+    }
+    addHelp(help) {
+        this.help = help;
+        return this;
+    }
+    addSubOption(command, help, func, extras = []) {
+        this.opts.push({ command, help, func, extras });
+        return this;
+    }
+    configure(program) {
+        const thisCmd = this;
+        let command = program.command(thisCmd.command);
+        if (this.help) {
+            command = command.description((0, utils_1.getHelpDescription)(thisCmd.help));
+        }
+        for (let opt of thisCmd.opts) {
+            command = command.option(opt.command, (0, utils_1.getSubHelpDescription)(opt.help));
+        }
+        command.helpOption("--help", (0, utils_1.getSubHelpDescription)(`Get help with ${this.command} options`));
+        command.action((options) => __awaiter(this, void 0, void 0, function* () {
+            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];
+                        yield opt.func(input);
+                        executed = true;
+                    }
+                }
+                if (found && !executed) {
+                    console.log((0, utils_1.error)(`${Object.keys(options)[0]} is an option, not an operation.`));
+                }
+                else if (!executed) {
+                    console.log((0, utils_1.error)(`Unknown ${this.command} option.`));
+                    command.help();
+                }
+            }
+            catch (err) {
+                console.log((0, utils_1.error)(err));
+            }
+        }));
+    }
+}
+exports.Command = Command;

package/dist/structures/ConfigManager.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigManager = void 0;
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const { error } = require("../utils");
+class ConfigManager {
+    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) {
+        fs.writeFileSync(this.path, JSON.stringify(json));
+    }
+    getValue(key) {
+        return this.config[key];
+    }
+    setValue(key, value) {
+        this.config = Object.assign(Object.assign({}, this.config), { [key]: value });
+    }
+    removeKey(key) {
+        const updated = Object.assign({}, this.config);
+        delete updated[key];
+        this.config = updated;
+    }
+}
+exports.ConfigManager = ConfigManager;