@faable/faable 1.4.10 → 1.4.11

package/dist/builder/docker/index.js

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,26 @@
+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/{commands/deploy/node-pipeline/bundle_docker.js → builder/node/prepare_dockerfile.js}

@@ -1,10 +1,7 @@
-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);
@@ -24,20 +21,18 @@ Handlebars.registerHelper("escape", function (variable) {
 // Docker template file
 const docker_template = Handlebars.compile(dockerfile);
 const entrypoint_template = Handlebars.compile(entrypoint);
-const bundle_docker = async (props) => {
-    const { app, workdir, template_context } = props;
+const prepare_dockerfile = async (ctx, params) => {
+    const { app, workdir, log, config } = ctx;
+    const { template_context } = params;
     const entrypoint_custom = entrypoint_template(template_context);
-    const start_command = Configuration.instance().startCommand;
-    log.info(`⚙️ Start command: ${start_command}`);
+    const start_command = config.getConfigProperty("startCommand", "npm run start");
+    log.info(`✅ Start command set to "${start_command}"`);
     const dockerfile = docker_template({
         from: template_context.from,
         entry_script: entrypoint_custom,
         start_command,
     });
-    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 });
+    return { dockerfile };
 };
 
-export { bundle_docker };
+export { prepare_dockerfile };

package/dist/builder/python/index.js

@@ -0,0 +1,5 @@
+const builder = async (ctx) => {
+    throw new Error(`Python builder is not implemented`);
+};
+
+export { builder, builder as default };

package/dist/commands/deploy/check_environment.js

@@ -5,7 +5,6 @@ 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,13 +2,19 @@ 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;
@@ -17,31 +23,35 @@ const deploy_command = async (args) => {
     }
     // Get app from Faable API
     const app = await api.getBySlug(name);
-    // 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(`🚀 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(),
+    };
+    // 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 || {}),
         });
+        log.info(`🌍 Deployment created -> https://${app.url}`);
     }
     else {
-        throw new Error(`No build pipeline for runtime=${runtime.name}`);
+        log.info(`❌ Upload canceled, remove --onlybuild otherwise`);
     }
-    // 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,6 +13,11 @@ const deploy = {
             alias: "w",
             type: "string",
             description: "Working directory",
+        })
+            .option("onlybuild", {
+            type: "boolean",
+            default: false,
+            description: "Just build",
         })
             .showHelpOnFail(false);
     },

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

@@ -1,13 +1,14 @@
 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,8 +1,6 @@
 const strategy_docker = async (workdir) => {
     return {
-        runtime: {
-            name: "docker",
-        },
+        runtime: "docker",
     };
 };
 

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

@@ -1,7 +1,5 @@
 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
@@ -12,29 +10,13 @@ import { log } from '../../../../log.js';
 const strategy_nodejs = async (workdir) => {
     const packageJSONFile = path__default.join(workdir, "package.json");
     // Check we have a valid name
-    const { name, engines } = fs.readJSONSync(packageJSONFile);
+    const { name } = 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: {
-            name: "node",
-            version: runtime_version,
-        },
+        runtime: "node",
     };
 };
 

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

@@ -0,0 +1,19 @@
+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 };

package/dist/lib/Configuration.js

@@ -27,11 +27,8 @@ class Configuration {
         }
         return Configuration._instance;
     }
-    get startCommand() {
-        return this.config.startCommand || "npm run start";
-    }
-    get buildCommand() {
-        return this.config.buildCommand;
+    getConfigProperty(name, defaultValue) {
+        return this.config[name] || defaultValue;
     }
 }
 

package/dist/log.js

@@ -1,13 +1,11 @@
 import pino from 'pino';
-import 'pino-pretty';
+import pretty from 'pino-pretty';
 
-const log = pino({
-    transport: {
-        target: "pino-pretty",
-        options: {
-            colorize: true,
-        },
-    },
-});
+const log = pino(pretty({
+    colorize: true,
+    messageFormat: "{timestamp}{if runtime}⚙️:{runtime} - {end}{msg}",
+    ignore: "runtime",
+    singleLine: 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": "^9.4.0",
+    "pino-pretty": "^11.0.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.10",
+  "version": "1.4.11",
   "bin": {
     "faable": "bin/faable.js"
   },

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

@@ -1,31 +0,0 @@
-import fs from 'fs-extra';
-import path__default from 'path';
-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);
-    // 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`);
-    }
-    // Detect deployment type
-    let type = "node";
-    if (pkg.dependencies["next"]) {
-        type = "next";
-    }
-    log.info(`⚡️ Detected deployment type=${type}`);
-    return {
-        build_script,
-        type,
-    };
-};
-
-export { analyze_package };

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

@@ -1,25 +0,0 @@
-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/node-pipeline/index.js

@@ -1,25 +0,0 @@
-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 };