@faable/faable 1.3.15 → 1.4.1

package/dist/api/context.js

@@ -1,9 +1,9 @@
-import { ConfigStore } from '../lib/ConfigStore.js';
+import { CredentialsStore } from '../lib/CredentialsStore.js';
 import { FaableApi } from './FaableApi.js';
 import { apikey_strategy } from './strategies/apikey.strategy.js';
 
 const context = async () => {
-    const store = new ConfigStore();
+    const store = new CredentialsStore();
     const apikey = process.env.FAABLE_APIKEY || (await store.loadCredentials())?.apikey;
     return {
         api: FaableApi.create({ authStrategy: apikey_strategy, auth: { apikey } }),

package/dist/commands/configure/index.js

@@ -1,4 +1,4 @@
-import { ConfigStore } from '../../lib/ConfigStore.js';
+import { CredentialsStore } from '../../lib/CredentialsStore.js';
 import prompts from 'prompts';
 
 const configure = {
@@ -16,7 +16,7 @@ const configure = {
     },
     handler: async (args) => {
         const { app_name, workdir, api, remove } = args;
-        const store = new ConfigStore();
+        const store = new CredentialsStore();
         if (remove) {
             await store.deleteCredentials();
         }

package/dist/commands/deploy/check_environment.js

@@ -1,8 +1,8 @@
-import { cmd } from './cmd.js';
+import { cmd } from '../../lib/cmd.js';
 
 const check_environment = async () => {
     try {
-        await cmd("docker", ["ps"]);
+        await cmd("docker ps");
     }
     catch (error) {
         console.log(error);

package/dist/commands/deploy/deploy_command.js

@@ -1,55 +1,43 @@
 import { log } from '../../log.js';
-import { bundle_docker } from './bundle_docker.js';
 import { upload_tag } from './upload_tag.js';
 import { check_environment } from './check_environment.js';
-import { analyze_package } from './analyze_package.js';
 import { context } from '../../api/context.js';
-import { build_project } from './build_project.js';
-import fs from 'fs-extra';
-import path__default from 'path';
+import { build_node } from './node-pipeline/index.js';
+import { runtime_detection } from './runtime-detect/runtime_detection.js';
+import { cmd } from '../../lib/cmd.js';
 
-const get_app = async (api, app_slug, workdir) => {
-    let slug;
-    if (app_slug) {
-        slug = app_slug;
-    }
-    else {
-        const packageJSONFile = path__default.join(workdir, "package.json");
-        if (!fs.existsSync(packageJSONFile)) {
-            throw new Error("Not found package.json");
-        }
-        const { name } = fs.readJSONSync(packageJSONFile);
-        if (!name) {
-            throw new Error("Missing name in package.json");
-        }
-        slug = name;
-    }
-    return api.getBySlug(slug);
-};
 const deploy_command = async (args) => {
     const workdir = args.workdir || process.cwd();
-    // Get registry data from api.faable.com
     const { api } = await context();
-    const app = await get_app(api, args.app_slug, workdir);
+    // Resolve runtime
+    const { app_name, runtime, runtime_version } = await runtime_detection(workdir);
+    const name = args.app_slug || app_name;
+    if (!name) {
+        throw new Error("Missing <app_name>");
+    }
+    // Get app from Faable API
+    const app = await api.getBySlug(name);
     // Check if we can build docker images
     await check_environment();
-    log.info(`🚀 Preparing to build ${app.name} [${app.id}]`);
-    // Analyze package.json to check if build is needed
-    const { build_script, type } = await analyze_package({ workdir });
-    await build_project({ app, build_script });
-    // Bundle project inside a docker image
-    const { tagname } = await bundle_docker({
-        app,
-        workdir,
-        template_context: {
-            from: "node:18.12.0-slim",
-            start_script: "start",
-        },
-    });
+    log.info(`🚀 Deploying [${app.name}] runtime=${runtime}-${runtime_version} app_id=${app.id}`);
+    let type;
+    if (runtime == "node") {
+        const node_result = await build_node(app, workdir);
+        type = node_result.type;
+    }
+    else if (runtime == "docker") {
+        type = "node";
+        await cmd(`docker build -t ${app.id} .`, {
+            enableOutput: true,
+        });
+    }
+    else {
+        throw new Error(`No build pipeline for runtime=${runtime}`);
+    }
     // Upload to Faable registry
-    const { image_tag } = await upload_tag({ app, api, tagname });
+    const { upload_tagname } = await upload_tag({ app, api });
     // Create a deployment for this image
-    await api.createDeployment({ app_id: app.id, image: image_tag, type });
+    await api.createDeployment({ app_id: app.id, image: upload_tagname, type });
     log.info(`🌍 Deployment created -> https://${app.url}`);
 };
 

package/dist/commands/deploy/{analyze_package.js → node-pipeline/analyze_package.js}

@@ -1,16 +1,12 @@
 import fs from 'fs-extra';
 import path__default from 'path';
-import { log } from '../../log.js';
+import { log } from '../../../log.js';
 
 const analyze_package = async (params) => {
     const workdir = params.workdir;
     const package_file = path__default.join(path__default.resolve(workdir), "package.json");
     log.info(`Loading config from package.json...`);
     const pkg = await fs.readJSON(package_file);
-    // Package must have a start script
-    if (!pkg?.scripts?.start) {
-        throw new Error("Missing start script");
-    }
     // Check if build is required to run
     const build_script = process.env.FAABLE_NPM_BUILD_SCRIPT
         ? process.env.FAABLE_NPM_BUILD_SCRIPT
@@ -25,7 +21,7 @@ const analyze_package = async (params) => {
     if (pkg.dependencies["next"]) {
         type = "next";
     }
-    log.info(`⚙️ Detected deployment type=${type}`);
+    log.info(`⚡️ Detected deployment type=${type}`);
     return {
         build_script,
         type,

package/dist/commands/deploy/node-pipeline/build_project.js

@@ -0,0 +1,25 @@
+import { log } from '../../../log.js';
+import { cmd } from '../../../lib/cmd.js';
+import { Configuration } from '../../../lib/Configuration.js';
+
+const build_project = async (args) => {
+    const build_script = args.build_script;
+    const build_command = build_script
+        ? `yarn run ${build_script}`
+        : Configuration.instance().buildCommand;
+    if (build_command) {
+        const cwd = args.cwd || process.cwd();
+        log.info(`⚙️ Building project [${build_command}]...`);
+        const timeout = 1000 * 60 * 100; // 100 minute timeout
+        await cmd(build_command, {
+            timeout,
+            cwd,
+            enableOutput: true,
+        });
+    }
+    else {
+        log.info(`⚡️ No build step`);
+    }
+};
+
+export { build_project };

package/dist/commands/deploy/{bundle_docker.js → node-pipeline/bundle_docker.js}

@@ -1,13 +1,14 @@
-import { log } from '../../log.js';
-import { cmd } from './cmd.js';
+import { log } from '../../../log.js';
+import { cmd } from '../../../lib/cmd.js';
 import fs from 'fs-extra';
 import Handlebars from 'handlebars';
 import * as path from 'path';
 import { fileURLToPath } from 'url';
+import { Configuration } from '../../../lib/Configuration.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
-const templates_dir = path.join(__dirname, "../../../templates");
+const templates_dir = path.join(__dirname, "templates");
 const dockerfile = fs.readFileSync(`${templates_dir}/Dockerfile`).toString();
 const entrypoint = fs
     .readFileSync(`${templates_dir}/entrypoint.sh`)
@@ -27,21 +28,14 @@ const bundle_docker = async (props) => {
     const { app, workdir, template_context } = props;
     const entrypoint_custom = entrypoint_template(template_context);
     const dockerfile = docker_template({
-        ...template_context,
+        from: template_context.from,
         entry_script: entrypoint_custom,
+        start_command: Configuration.instance().startCommand,
     });
     log.info(`📦 Packaging inside a docker image`);
-    const tagname = app.id;
+    // Build options
     const timeout = 10 * 60 * 1000; // 10 minute timeout
-    const command = [
-        "-c",
-        `docker build -t ${tagname} ${workdir} -f -<<EOF\n${dockerfile}\nEOF`,
-    ];
-    await cmd("/bin/bash", command, { timeout, enableOutput: true });
-    log.info(`⚙️  Image ready [tag:${tagname}]`);
-    return {
-        tagname,
-    };
+    await cmd(`docker build -t ${app.id} ${workdir} -f -<<EOF\n${dockerfile}\nEOF`, { timeout, enableOutput: true });
 };
 
 export { bundle_docker };

package/dist/commands/deploy/node-pipeline/index.js

@@ -0,0 +1,21 @@
+import { bundle_docker } from './bundle_docker.js';
+import { analyze_package } from './analyze_package.js';
+import { build_project } from './build_project.js';
+
+const build_node = async (app, workdir) => {
+    // log.info(`🚀 Build Toolchain ${app.name} [${app.id}]`);
+    // Analyze package.json to check if build is needed
+    const { build_script, type } = await analyze_package({ workdir });
+    await build_project({ app, build_script });
+    // Bundle project inside a docker image
+    await bundle_docker({
+        app,
+        workdir,
+        template_context: {
+            from: "node:18.12.0-slim",
+        },
+    });
+    return { type };
+};
+
+export { build_node };

package/{templates → dist/commands/deploy/node-pipeline/templates}/Dockerfile

@@ -7,7 +7,7 @@ WORKDIR /faable/app
 # Environment variables for runtime
 ENV PORT=80
 ENV NODE_ENV=production
-ENV START_SCRIPT=start
+ENV START_COMMAND="{{start_command}}"
 
 # Copy Usercode
 COPY . .

package/{templates → dist/commands/deploy/node-pipeline/templates}/entrypoint.sh

@@ -5,4 +5,4 @@ NPM_VERSION=$(npm --version)
 YARN_VERSION=$(yarn --version)
 
 echo "Faable Cloud · [node $NODE_VERSION] [npm $NPM_VERSION] [yarn $YARN_VERSION]"
-npm run $START_SCRIPT
+eval $START_COMMAND

package/dist/commands/deploy/runtime-detect/helpers/has_any_of_files.js

@@ -0,0 +1,14 @@
+import fs from 'fs-extra';
+import path__default from 'path';
+
+const has_any_of_files = (files, workdir) => {
+    for (let name of files) {
+        const filename = path__default.join(workdir, name);
+        if (fs.existsSync(filename)) {
+            return true;
+        }
+    }
+    return false;
+};
+
+export { has_any_of_files };

package/dist/commands/deploy/runtime-detect/runtime_detection.js

@@ -0,0 +1,20 @@
+import { strategy_nodejs } from './strategies/nodejs.js';
+import * as R from 'ramda';
+import { has_any_of_files } from './helpers/has_any_of_files.js';
+import { strategy_python } from './strategies/python.js';
+import { strategy_docker } from './strategies/docker.js';
+
+const runtime_detection = async (workdir) => {
+    const has = R.curry(has_any_of_files);
+    const strategy = R.cond([
+        [has(["package.json"]), R.always(strategy_nodejs)],
+        [has(["requirements.txt"]), R.always(strategy_python)],
+        [has(["Dockerfile"]), R.always(strategy_docker)],
+    ])(workdir);
+    if (!strategy) {
+        throw new Error("Cannot detect project type");
+    }
+    return strategy(workdir);
+};
+
+export { runtime_detection };

package/dist/commands/deploy/runtime-detect/strategies/docker.js

@@ -0,0 +1,8 @@
+const strategy_docker = async (workdir) => {
+    return {
+        runtime: "docker",
+        runtime_version: "docker",
+    };
+};
+
+export { strategy_docker };

package/dist/commands/deploy/runtime-detect/strategies/nodejs.js

@@ -0,0 +1,24 @@
+import fs from 'fs-extra';
+import path__default from 'path';
+
+/**
+ * Strategy to detect app name from package.json
+ * @param api
+ * @param workdir
+ * @returns
+ */
+const strategy_nodejs = async (workdir) => {
+    const packageJSONFile = path__default.join(workdir, "package.json");
+    // Check we have a valid name
+    const { name } = fs.readJSONSync(packageJSONFile);
+    if (!name) {
+        throw new Error("Missing name in package.json");
+    }
+    return {
+        app_name: name,
+        runtime: "node",
+        runtime_version: "18",
+    };
+};
+
+export { strategy_nodejs };

package/dist/commands/deploy/runtime-detect/strategies/python.js

@@ -0,0 +1,22 @@
+import fs from 'fs-extra';
+import path__default from 'path';
+
+const strategy_python = async (workdir) => {
+    const runtime_config = path__default.join(workdir, "runtime.txt");
+    // Default runtime
+    let runtime_version = "3.11.3";
+    // Select runtime based on config
+    if (fs.existsSync(runtime_config)) {
+        const runtime_data = fs.readFileSync(runtime_config).toString();
+        if (!runtime_data.startsWith("python-")) {
+            throw new Error("runtime.txt must have runtime format with python-<version>");
+        }
+        runtime_version = runtime_data.split("-")[1];
+    }
+    return {
+        runtime: "python",
+        runtime_version,
+    };
+};
+
+export { strategy_python };

package/dist/commands/deploy/upload_tag.js

@@ -1,22 +1,21 @@
 import { log } from '../../log.js';
-import { cmd } from './cmd.js';
+import { cmd } from '../../lib/cmd.js';
 
 const upload_tag = async (args) => {
-    const { api, app, tagname } = args;
+    const { api, app } = args;
     log.info(`🔁 Uploading...`);
     const registry = await api.getRegistry(app.id);
     // Registry login
     const { user, password, hostname, image } = registry;
-    const docker_login_cmd = `echo "${password}" | docker login --username ${user} --password-stdin ${hostname}`;
-    await cmd("/bin/bash", ["-c", docker_login_cmd]);
+    await cmd(`echo "${password}" | docker login --username ${user} --password-stdin ${hostname}`);
     // Tag image for production
-    const image_tag = `${hostname}/${image}`;
-    await cmd("docker", ["tag", tagname, image_tag]);
+    const upload_tagname = `${hostname}/${image}`;
+    await cmd(`docker tag ${app.id} ${upload_tagname}`);
     // Upload the image to faable registry
-    await cmd("docker", ["push", image_tag]);
+    await cmd(`docker push ${upload_tagname}`);
     log.info(`✅ Upload completed.`);
     return {
-        image_tag,
+        upload_tagname,
     };
 };
 

package/dist/commands/init/ConfigurationHelper.js

@@ -2,13 +2,13 @@ import path__default from 'path';
 import fs from 'fs-extra';
 import { log } from '../../log.js';
 import prompts from 'prompts';
-import { ConfigStore } from '../../lib/ConfigStore.js';
+import { CredentialsStore } from '../../lib/CredentialsStore.js';
 import yaml from 'yaml';
 
 class ConfigurationHelper {
     store;
     constructor() {
-        this.store = new ConfigStore();
+        this.store = new CredentialsStore();
     }
     get workflows_dir() {
         return path__default.join(process.cwd(), ".github", "workflows");

package/dist/index.js

@@ -6,11 +6,27 @@ import { deploy } from './commands/deploy/index.js';
 import { log } from './log.js';
 import { init } from './commands/init/index.js';
 import { version } from './config.js';
+import { Configuration } from './lib/Configuration.js';
 
 const yg = yargs();
 yg.scriptName("faable")
     .middleware(function (argv) {
     console.log(`Faable CLI ${version}`);
+}, true)
+    .option("c", {
+    alias: "config",
+    description: "Path to the local `faable.json` file",
+    string: true,
+})
+    .middleware(function (argv) {
+    if (argv.config) {
+        Configuration.instance().setConfigFile(argv.config, {
+            ignoreWarnings: false,
+        });
+    }
+    else {
+        Configuration.instance();
+    }
 }, true)
     .command(deploy)
     .command(apps)

package/dist/lib/Configuration.js

@@ -0,0 +1,38 @@
+import path__default from 'path';
+import fs from 'fs-extra';
+import { log } from '../log.js';
+
+class Configuration {
+    static _instance;
+    config;
+    constructor() {
+        // Try to read default config file
+        this.setConfigFile("faable.json", { ignoreWarnings: true });
+    }
+    setConfigFile(file, options) {
+        const config_file = path__default.join(process.cwd(), file);
+        if (fs.existsSync(config_file)) {
+            this.config = fs.readJSONSync(config_file);
+            log.info(`Loaded configuration from: ${file}`);
+        }
+        else {
+            if (!options.ignoreWarnings) {
+                log.warn(`Cannot read Faable config file ${file}`);
+            }
+        }
+    }
+    static instance() {
+        if (Configuration._instance) {
+            return Configuration._instance;
+        }
+        return new Configuration();
+    }
+    get startCommand() {
+        return this.config?.startCommand || "npm run start";
+    }
+    get buildCommand() {
+        return this.config?.buildCommand;
+    }
+}
+
+export { Configuration };

package/dist/lib/{ConfigStore.js → CredentialsStore.js}

@@ -3,7 +3,7 @@ import os from 'os';
 import fs from 'fs-extra';
 import { log } from '../log.js';
 
-class ConfigStore {
+class CredentialsStore {
     log;
     faable_home;
     constructor(log$1 = log) {
@@ -33,4 +33,4 @@ class ConfigStore {
     }
 }
 
-export { ConfigStore };
+export { CredentialsStore };

package/dist/{commands/deploy → lib}/cmd.js

@@ -1,11 +1,11 @@
 import { spawn } from 'promisify-child-process';
 
-const cmd = async (cmd, args, params) => {
+const cmd = async (cmd, config) => {
     // Defaults
-    const enableOutput = params?.enableOutput || false;
-    const timeout = params?.timeout;
-    const cwd = params?.cwd;
-    const child = spawn(cmd, args, {
+    const enableOutput = config?.enableOutput || false;
+    const timeout = config?.timeout;
+    const cwd = config?.cwd;
+    const child = spawn("/bin/bash", ["-c", cmd], {
         encoding: "utf8",
         stdio: enableOutput ? "inherit" : "pipe",
         timeout,
@@ -23,9 +23,9 @@ const cmd = async (cmd, args, params) => {
         return result;
     }
     catch (error) {
-        const output = out_data.map((b) => b.toString()).join("\n");
-        console.log(output);
-        throw new Error(`Error running command`);
+        out_data.map((b) => b.toString()).join("\n");
+        // console.log(output);
+        throw new Error(`Command error: ${cmd}`);
     }
 };
 

package/dist/log.js

@@ -1,7 +1,6 @@
 import pino from 'pino';
 import 'pino-pretty';
 
-//import * as core from "@actions/core";
 const log = pino({
     transport: {
         target: "pino-pretty",

package/package.json

@@ -9,11 +9,12 @@
     "pino-pretty": "^9.4.0",
     "promisify-child-process": "^4.1.1",
     "prompts": "^2.4.2",
+    "ramda": "^0.29.0",
     "tslib": "^2.4.1",
     "yaml": "^2.2.2",
     "yargs": "^17.6.2"
   },
-  "version": "1.3.15",
+  "version": "1.4.1",
   "bin": {
     "faable": "bin/faable.js"
   },

package/dist/commands/deploy/build_project.js

@@ -1,21 +0,0 @@
-import { log } from '../../log.js';
-import { cmd } from './cmd.js';
-
-const build_project = async (args) => {
-    const build_script = args.build_script;
-    if (build_script) {
-        const cwd = args.cwd || process.cwd();
-        log.info(`⚡️ Running build [${build_script}]...`);
-        const timeout = 1000 * 60 * 100; // 100 minute timeout
-        await cmd("yarn", ["run", build_script], {
-            timeout,
-            cwd,
-            enableOutput: true,
-        });
-    }
-    else {
-        log.info(`⚡️ No build step`);
-    }
-};
-
-export { build_project };