@faable/faable 1.4.12 → 1.5.0

package/dist/commands/deploy/check_environment.js

@@ -5,6 +5,7 @@ const check_environment = async () => {
         await cmd("docker ps");
     }
     catch (error) {
+        console.log(error);
         throw new Error(`Docker is not running`);
     }
 };

package/dist/commands/deploy/deploy_command.js

@@ -2,19 +2,13 @@ import { log } from '../../log.js';
 import { upload_tag } from './upload_tag.js';
 import { check_environment } from './check_environment.js';
 import { context } from '../../api/context.js';
+import { build_node } from './node-pipeline/index.js';
 import { runtime_detection } from './runtime-detect/runtime_detection.js';
-import { import_builder } from '../../builder/index.js';
-import { Configuration } from '../../lib/Configuration.js';
 import { cmd } from '../../lib/cmd.js';
 
 const deploy_command = async (args) => {
     const workdir = args.workdir || process.cwd();
-    const flags = {
-        upload: args.onlybuild ? false : true,
-    };
     const { api } = await context();
-    // Check if we can build docker images
-    await check_environment();
     // Resolve runtime
     const { app_name, runtime } = await runtime_detection(workdir);
     const name = args.app_slug || app_name;
@@ -23,35 +17,31 @@ const deploy_command = async (args) => {
     }
     // Get app from Faable API
     const app = await api.getBySlug(name);
-    log.info(`🚀 Deploying ${app.name} (${app.id}) runtime=${runtime}`);
-    // Select builder
-    let builder = await import_builder(runtime);
-    const ctx = {
-        app,
-        workdir,
-        log: log.child({ runtime }),
-        config: Configuration.instance(workdir),
-    };
-    // Do build
-    const { dockerfile, params } = await builder(ctx);
-    // Compile docker image
-    log.info(`📦 Packaging...`);
-    const timeout = 10 * 60 * 1000; // 10 minute timeout
-    await cmd(`docker build -t ${app.id} ${workdir} -f -<<EOF\n${dockerfile}\nEOF`, { timeout, enableOutput: true });
-    // Upload to Faable registry
-    if (flags.upload) {
-        const { upload_tagname } = await upload_tag({ app, api });
-        // Create a deployment for this image
-        await api.createDeployment({
-            app_id: app.id,
-            image: upload_tagname,
-            ...(params || {}),
+    // Check if we can build docker images
+    await check_environment();
+    log.info(`🚀 Deploying ${app.name} (${app.id}) runtime=${runtime.name}-${runtime.version} `);
+    let type;
+    if (runtime.name == "node") {
+        const node_result = await build_node(app, {
+            workdir,
+            runtime,
+        });
+        type = node_result.type;
+    }
+    else if (runtime.name == "docker") {
+        type = "node";
+        await cmd(`docker build -t ${app.id} .`, {
+            enableOutput: true,
         });
-        log.info(`🌍 Deployment created -> https://${app.url}`);
     }
     else {
-        log.info(`❌ Upload canceled, remove --onlybuild otherwise`);
+        throw new Error(`No build pipeline for runtime=${runtime.name}`);
     }
+    // Upload to Faable registry
+    const { upload_tagname } = await upload_tag({ app, api });
+    // Create a deployment for this image
+    await api.createDeployment({ app_id: app.id, image: upload_tagname, type });
+    log.info(`🌍 Deployment created -> https://${app.url}`);
 };
 
 export { deploy_command };

package/dist/commands/deploy/index.js

@@ -13,11 +13,6 @@ const deploy = {
             alias: "w",
             type: "string",
             description: "Working directory",
-        })
-            .option("onlybuild", {
-            type: "boolean",
-            default: false,
-            description: "Just build",
         })
             .showHelpOnFail(false);
     },

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

@@ -0,0 +1,34 @@
+import fs from 'fs-extra';
+import path__default from 'path';
+import { log } from '../../../log.js';
+import * as R from 'ramda';
+
+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);
+    // Check if build is required to run
+    const build_script = process.env.FAABLE_NPM_BUILD_SCRIPT
+        ? process.env.FAABLE_NPM_BUILD_SCRIPT
+        : pkg?.scripts["build"]
+            ? "build"
+            : null;
+    if (!build_script) {
+        log.info(`No build script on package.json`);
+    }
+    let type = "node";
+    // Detect nextjs deployment type
+    const next_dep = R.lensPath(["dependencies", "next"]);
+    const next_devdep = R.lensPath(["devDependencies", "next"]);
+    if (R.view(next_dep, pkg) || R.view(next_devdep, pkg)) {
+        type = "next";
+    }
+    log.info(`⚡️ Detected deployment type=${type}`);
+    return {
+        build_script,
+        type,
+    };
+};
+
+export { analyze_package };

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/{builder/node/prepare_dockerfile.js → commands/deploy/node-pipeline/bundle_docker.js}

@@ -1,7 +1,10 @@
+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);
@@ -21,18 +24,20 @@ Handlebars.registerHelper("escape", function (variable) {
 // Docker template file
 const docker_template = Handlebars.compile(dockerfile);
 const entrypoint_template = Handlebars.compile(entrypoint);
-const prepare_dockerfile = async (ctx, params) => {
-    const { app, workdir, log, config } = ctx;
-    const { template_context } = params;
+const bundle_docker = async (props) => {
+    const { app, workdir, template_context } = props;
     const entrypoint_custom = entrypoint_template(template_context);
-    const start_command = config.getConfigProperty("startCommand", "npm run start");
-    log.info(`✅ Start command set to "${start_command}"`);
+    const start_command = Configuration.instance().startCommand;
+    log.info(`⚙️ Start command: ${start_command}`);
     const dockerfile = docker_template({
         from: template_context.from,
         entry_script: entrypoint_custom,
         start_command,
     });
-    return { dockerfile };
+    log.info(`📦 Packaging inside a docker image`);
+    // Build options
+    const timeout = 10 * 60 * 1000; // 10 minute timeout
+    await cmd(`docker build -t ${app.id} ${workdir} -f -<<EOF\n${dockerfile}\nEOF`, { timeout, enableOutput: true });
 };
 
-export { prepare_dockerfile };
+export { bundle_docker };

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

@@ -0,0 +1,25 @@
+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, options) => {
+    // log.info(`🚀 Build Toolchain ${app.name} [${app.id}]`);
+    const { workdir, runtime } = options;
+    if (!runtime.version) {
+        throw new Error("Runtime version not specified for node");
+    }
+    // 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:${runtime.version}`,
+        },
+    });
+    return { type };
+};
+
+export { build_node };

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

@@ -1,14 +1,13 @@
 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(["requirements.txt"]), R.always(strategy_python)],
         [has(["Dockerfile"]), R.always(strategy_docker)],
     ])(workdir);
     if (!strategy) {

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

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

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

@@ -1,5 +1,7 @@
 import fs from 'fs-extra';
 import path__default from 'path';
+import { cmd } from '../../../../lib/cmd.js';
+import { log } from '../../../../log.js';
 
 /**
  * Strategy to detect app name from package.json
@@ -10,13 +12,29 @@ import path__default from 'path';
 const strategy_nodejs = async (workdir) => {
     const packageJSONFile = path__default.join(workdir, "package.json");
     // Check we have a valid name
-    const { name } = fs.readJSONSync(packageJSONFile);
+    const { name, engines } = fs.readJSONSync(packageJSONFile);
     if (!name) {
         throw new Error("Missing name in package.json");
     }
+    // Use engines.node if found
+    let runtime_version = "18.19.0";
+    if (engines?.node) {
+        try {
+            const check_cmd = `npm view node@"${engines.node}" version | tail -n 1 | cut -d "'" -f2`;
+            const out = await cmd(check_cmd);
+            runtime_version = out.stdout.toString();
+            log.info(`Using node@${runtime_version} from engines in package.json (${engines.node})`);
+        }
+        catch (e) {
+            throw new Error(`Node version is not valid (${engines.node})`);
+        }
+    }
     return {
         app_name: name,
-        runtime: "node",
+        runtime: {
+            name: "node",
+            version: runtime_version,
+        },
     };
 };
 

package/dist/index.js

@@ -6,6 +6,7 @@ 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")
@@ -17,6 +18,16 @@ yg.scriptName("faable")
     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)
     .command(configure)

package/dist/lib/Configuration.js

@@ -3,16 +3,14 @@ import fs from 'fs-extra';
 import { log } from '../log.js';
 
 class Configuration {
-    workdir;
     static _instance;
     config = {};
-    constructor(workdir) {
-        this.workdir = workdir;
+    constructor() {
         // Try to read default config file
         this.setConfigFile("faable.json", { ignoreWarnings: true });
     }
     setConfigFile(file, options) {
-        const config_file = path__default.join(this.workdir, file);
+        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}`);
@@ -23,14 +21,17 @@ class Configuration {
             }
         }
     }
-    static instance(workdir) {
+    static instance() {
         if (!Configuration._instance) {
-            Configuration._instance = new Configuration(workdir);
+            Configuration._instance = new Configuration();
         }
         return Configuration._instance;
     }
-    getConfigProperty(name, defaultValue) {
-        return this.config[name] || defaultValue;
+    get startCommand() {
+        return this.config.startCommand || "npm run start";
+    }
+    get buildCommand() {
+        return this.config.buildCommand;
     }
 }
 

package/dist/log.js

@@ -1,11 +1,13 @@
 import pino from 'pino';
-import pretty from 'pino-pretty';
+import 'pino-pretty';
 
-const log = pino(pretty({
-    colorize: true,
-    messageFormat: "{timestamp}{if runtime}⚙️:{runtime} - {end}{msg}",
-    ignore: "runtime",
-    singleLine: true,
-}));
+const log = pino({
+    transport: {
+        target: "pino-pretty",
+        options: {
+            colorize: true,
+        },
+    },
+});
 
 export { log };

package/package.json

@@ -6,7 +6,7 @@
     "fs-extra": "^11.1.0",
     "handlebars": "^4.7.7",
     "pino": "^8.11.0",
-    "pino-pretty": "^11.0.0",
+    "pino-pretty": "^9.4.0",
     "promisify-child-process": "^4.1.1",
     "prompts": "^2.4.2",
     "ramda": "^0.29.0",
@@ -14,7 +14,7 @@
     "yaml": "^2.2.2",
     "yargs": "^17.6.2"
   },
-  "version": "1.4.12",
+  "version": "1.5.0",
   "bin": {
     "faable": "bin/faable.js"
   },

package/dist/builder/docker/index.js

@@ -1,10 +0,0 @@
-import path__default from 'path';
-import fs from 'fs-extra';
-
-const builder = async (ctx) => {
-    const { app, workdir } = ctx;
-    const f = path__default.join(path__default.resolve(workdir), "Dockerfile");
-    return { dockerfile: (await fs.readFile(f)).toString() };
-};
-
-export { builder, builder as default };

package/dist/builder/index.js

@@ -1,17 +0,0 @@
-const builders = {
-    node: () => import('./node/index.js'),
-    python: () => import('./python/index.js'),
-    docker: () => import('./docker/index.js'),
-};
-const import_builder = async (runtime_name) => {
-    try {
-        let builder_module = await builders[runtime_name]();
-        return builder_module.default;
-    }
-    catch (e) {
-        console.log(e);
-        throw new Error(`Builder import error for ${runtime_name}`);
-    }
-};
-
-export { import_builder };

package/dist/builder/node/analyze_package.js

@@ -1,25 +0,0 @@
-import fs from 'fs-extra';
-import path__default from 'path';
-
-const analyze_package = async (ctx) => {
-    const { log, workdir } = ctx;
-    const node_modules_dir = path__default.join(path__default.resolve(workdir), "node_modules");
-    const installedModules = await fs.pathExists(node_modules_dir);
-    if (!installedModules) {
-        throw new Error("node_modules not found, please install packages first");
-    }
-    const package_file = path__default.join(path__default.resolve(workdir), "package.json");
-    const pkg = await fs.readJSON(package_file);
-    // Detect deployment type
-    let type = "node";
-    if (pkg.dependencies["next"]) {
-        type = "next";
-        log.info(`✅ Next.js ⚡️ project detected`);
-    }
-    return {
-        pkg,
-        type,
-    };
-};
-
-export { analyze_package };

package/dist/builder/node/build_project.js

@@ -1,27 +0,0 @@
-import { cmd } from '../../lib/cmd.js';
-
-const build_project = async (ctx, nodeCtx) => {
-    const { log, config, workdir } = ctx;
-    // Check if exists any type of builc command
-    let build_command = config.getConfigProperty("buildCommand", process.env.FAABLE_NPM_BUILD_COMMAND);
-    const build_script_name = config.getConfigProperty("buildScript", "build");
-    const build_script = nodeCtx.pkg.scripts[build_script_name];
-    // No build command but build script
-    if (!build_command && build_script) {
-        build_command = `npm run ${build_script_name}`;
-    }
-    if (build_command) {
-        log.info(`✅ Build command detected. Running "${build_command}"`);
-        const timeout = 1000 * 60 * 100; // 100 minute timeout
-        await cmd(build_command, {
-            timeout,
-            cwd: workdir,
-            enableOutput: true,
-        });
-    }
-    else {
-        log.info(`No build script in package.json`);
-    }
-};
-
-export { build_project };

package/dist/builder/node/engine_version.js

@@ -1,31 +0,0 @@
-import fs from 'fs-extra';
-import path__default from 'path';
-import { cmd } from '../../lib/cmd.js';
-
-const engine_version = async (ctx) => {
-    const { workdir, log } = ctx;
-    const packageJSONFile = path__default.join(workdir, "package.json");
-    // Check we have a valid name
-    const { name, engines } = fs.readJSONSync(packageJSONFile);
-    if (!name) {
-        throw new Error("Missing name in package.json");
-    }
-    // Use engines.node if found
-    let version = "18.19.0";
-    if (engines?.node) {
-        try {
-            const check_cmd = `npm view node@"${engines.node}" version | tail -n 1 | cut -d "'" -f2`;
-            const out = await cmd(check_cmd);
-            version = out.stdout.toString().trim();
-            log.info(`✅ Engine "${engines.node}" from package.json resolved to node@${version}`);
-        }
-        catch (e) {
-            throw new Error(`Node version is not valid (${engines.node})`);
-        }
-    }
-    return {
-        version,
-    };
-};
-
-export { engine_version };

package/dist/builder/node/index.js

@@ -1,26 +0,0 @@
-import { prepare_dockerfile } from './prepare_dockerfile.js';
-import { analyze_package } from './analyze_package.js';
-import { build_project } from './build_project.js';
-import { engine_version } from './engine_version.js';
-
-const builder = async (ctx) => {
-    // log.info(`🚀 Build Toolchain ${app.name} [${app.id}]`);
-    const { version } = await engine_version(ctx);
-    // Analyze package.json to check if build is needed
-    const nodeCtx = await analyze_package(ctx);
-    await build_project(ctx, nodeCtx);
-    // Bundle project inside a docker image
-    const { dockerfile } = await prepare_dockerfile(ctx, {
-        template_context: {
-            from: `node:${version}`,
-        },
-    });
-    return {
-        dockerfile,
-        params: {
-            type: nodeCtx.type,
-        },
-    };
-};
-
-export { builder, builder as default };

package/dist/builder/python/index.js

@@ -1,17 +0,0 @@
-import fs from 'fs-extra';
-import path__default from 'path';
-import { prepare_dockerfile } from './prepare_dockerfile.js';
-
-const builder = async (ctx) => {
-    const { workdir, log } = ctx;
-    const hasRequirements = fs.existsSync(path__default.join(path__default.resolve(workdir), "requirements.txt"));
-    if (!hasRequirements) {
-        throw new Error(`Missing requirements.txt`);
-    }
-    const { dockerfile } = await prepare_dockerfile(ctx);
-    return {
-        dockerfile,
-    };
-};
-
-export { builder, builder as default };

package/dist/builder/python/prepare_dockerfile.js

@@ -1,40 +0,0 @@
-import fs from 'fs-extra';
-import Handlebars from 'handlebars';
-import * as path from 'path';
-import { fileURLToPath } from 'url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const templates_dir = path.join(__dirname, "templates");
-const dockerfile = fs.readFileSync(`${templates_dir}/Dockerfile`).toString();
-const entrypoint = fs
-    .readFileSync(`${templates_dir}/entrypoint.sh`)
-    .toString("utf-8");
-Handlebars.registerHelper("escape", function (variable) {
-    //const escaped_quotes = variable.replace(/(['"])/g, "\\$1");
-    const escaped_lines = variable
-        .replace(/(['`\\])/g, "\\$1")
-        .replace(/([$])/g, "\\$1");
-    return escaped_lines.split("\n").join("\\n");
-    //return escaped_lines.split("\n").join("\\n");
-});
-// Docker template file
-const docker_template = Handlebars.compile(dockerfile);
-const entrypoint_template = Handlebars.compile(entrypoint);
-const prepare_dockerfile = async (ctx, params = {}) => {
-    const { app, workdir, log, config } = ctx;
-    const entrypoint_custom = entrypoint_template(params);
-    const start_command = config.getConfigProperty("startCommand");
-    if (!start_command) {
-        throw new Error(`Missing start command configuration`);
-    }
-    log.info(`✅ Start command set to "${start_command}"`);
-    const dockerfile = docker_template({
-        ...params,
-        entry_script: entrypoint_custom,
-        start_command,
-    });
-    return { dockerfile };
-};
-
-export { prepare_dockerfile };

package/dist/builder/python/templates/Dockerfile

@@ -1,26 +0,0 @@
-FROM python:3.9-slim
-
-RUN apt-get update && apt-get install -y locales locales-all && rm -rf /var/lib/apt/lists/*
-
-RUN sed -i '/es_ES.UTF-8/s/^# //g' /etc/locale.gen && \
-    locale-gen
-
-ENV LANG es_ES.UTF-8
-ENV LANGUAGE es_ES:es
-ENV LC_ALL es_ES.UTF-8    
-
-ENV PORT=80
-ENV START_COMMAND="{{start_command}}"
-
-WORKDIR /app
-
-COPY requirements.txt .
-
-RUN pip install --no-cache-dir -r requirements.txt
-
-COPY . .
-
-# Entrypoint stript
-RUN echo '{{{escape entry_script}}}' >> entrypoint.sh
-
-CMD ["/bin/sh", "./entrypoint.sh"]  

package/dist/builder/python/templates/entrypoint.sh

@@ -1,7 +0,0 @@
-#!/bin/sh
-
-PYTHON_VERSION=$(python --version)
-PIP_VERSION=$(pip --version)
-
-echo "Faable Cloud · [$PYTHON_VERSION] [$PIP_VERSION]"
-eval $START_COMMAND

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

@@ -1,19 +0,0 @@
-import fs from 'fs-extra';
-import path__default from 'path';
-
-const strategy_python = async (workdir) => {
-    const runtime_config = path__default.join(workdir, "runtime.txt");
-    // 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_data.split("-")[1];
-    }
-    return {
-        runtime: "python",
-    };
-};
-
-export { strategy_python };