@faable/faable 1.5.27 → 1.5.28

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

@@ -1,7 +1,7 @@
 import fs from 'fs-extra';
 import path__default from 'path';
 import { log } from '../../../log.js';
-import * as R from 'ramda';
+import { detect_framework } from './frameworks.js';
 
 const analyze_package = async (params) => {
     const workdir = params.workdir;
@@ -11,23 +11,24 @@ const analyze_package = async (params) => {
     // 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"]
+        : 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";
-    }
+    const has_start = Boolean(pkg?.scripts?.["start"]);
+    const { type, start_command, inject_serve } = detect_framework({
+        pkg,
+        workdir,
+        has_start,
+    });
     log.info(`⚡️ Detected deployment type=${type}`);
     return {
         build_script,
         type,
+        start_command,
+        inject_serve,
     };
 };
 

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

@@ -27,7 +27,11 @@ const entrypoint_template = Handlebars.compile(entrypoint);
 const build_docker = async (props) => {
     const { app, workdir, template_context } = props;
     const entrypoint_custom = entrypoint_template(template_context);
-    const start_command = Configuration.instance().startCommand;
+    // Precedence: explicit faable.json startCommand > framework-detected command
+    // (e.g. serving a static SPA) > default `npm run start`.
+    const start_command = Configuration.instance().configuredStartCommand ??
+        props.start_command ??
+        "npm run start";
     log.info(`⚙️ Start command: ${start_command}`);
     // NOTE: use slim to build projects
     const linux_distro = "slim";

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

@@ -0,0 +1,108 @@
+import fs from 'fs-extra';
+import path__default from 'path';
+import * as R from 'ramda';
+import { log } from '../../../log.js';
+
+const has_dep = (pkg, name) => Boolean(R.view(R.lensPath(["dependencies", name]), pkg) ||
+    R.view(R.lensPath(["devDependencies", name]), pkg));
+/**
+ * Read Angular's build output path from angular.json. Defaults to `dist` when
+ * it can't be resolved. Angular ≥17 (application builder) emits into
+ * `<outputPath>/browser`, so we append it when the project uses that builder.
+ */
+const resolve_angular_output = (workdir) => {
+    const fallback = "dist";
+    try {
+        const angular_json = fs.readJSONSync(path__default.join(workdir, "angular.json"));
+        const projects = angular_json?.projects ?? {};
+        const project_name = angular_json?.defaultProject ?? Object.keys(projects)[0];
+        const build = projects?.[project_name]?.architect?.build;
+        const output = build?.options?.outputPath;
+        if (!output)
+            return fallback;
+        const builder = build?.builder ?? "";
+        const is_application_builder = builder.includes("application") || builder.includes("browser-esbuild");
+        return is_application_builder ? path__default.join(output, "browser") : output;
+    }
+    catch {
+        return fallback;
+    }
+};
+/**
+ * Framework registry, evaluated in order. Order matters: Astro/SvelteKit/CRA
+ * pull Vite in transitively, so Vite must be the last static fallback.
+ */
+const FRAMEWORKS = [
+    // Next.js: handled by its own runtime_strategy/PVC, never static-served here.
+    { type: "next", deps: ["next"] },
+    {
+        type: "astro",
+        deps: ["astro"],
+        outputDir: "dist",
+        serveCommand: (dir) => `npx astro preview --host 0.0.0.0 --port $PORT`,
+    },
+    {
+        type: "gatsby",
+        deps: ["gatsby"],
+        outputDir: "public",
+        serveCommand: (dir) => `npx gatsby serve --host 0.0.0.0 --port $PORT`,
+    },
+    {
+        type: "cra",
+        deps: ["react-scripts"],
+        outputDir: "build",
+        injectServe: true,
+        serveCommand: (dir) => `npx serve -s ${dir} -l $PORT`,
+    },
+    {
+        type: "vue",
+        deps: ["@vue/cli-service"],
+        outputDir: "dist",
+        injectServe: true,
+        serveCommand: (dir) => `npx serve -s ${dir} -l $PORT`,
+    },
+    {
+        type: "angular",
+        deps: ["@angular/cli", "@angular-devkit/build-angular"],
+        injectServe: true,
+        resolveOutput: resolve_angular_output,
+        serveCommand: (dir) => `npx serve -s ${dir} -l $PORT`,
+    },
+    {
+        type: "vite",
+        deps: ["vite"],
+        outputDir: "dist",
+        serveCommand: (dir) => `npx vite preview --host 0.0.0.0 --port $PORT`,
+    },
+];
+/**
+ * Detect the framework from package.json and compute how to serve it.
+ *
+ * When the project defines its own `start` script we never override it (the app
+ * ships a real server — custom SSR, Nuxt, Remix, SvelteKit node-adapter, etc.),
+ * so `start_command`/`inject_serve` stay neutral.
+ */
+const detect_framework = (params) => {
+    const { pkg, workdir, has_start } = params;
+    const framework = FRAMEWORKS.find((fw) => fw.deps.some((dep) => has_dep(pkg, dep)));
+    if (!framework) {
+        return { type: "node", start_command: null, inject_serve: false };
+    }
+    // Static frameworks only override the start command when the project doesn't
+    // ship its own server.
+    if (framework.serveCommand && !has_start) {
+        const output_dir = framework.resolveOutput
+            ? framework.resolveOutput(workdir)
+            : framework.outputDir ?? "dist";
+        const start_command = framework.serveCommand(output_dir);
+        log.info(`No start script on package.json, serving ${framework.type} output (${output_dir}) with [${start_command}]`);
+        return {
+            type: framework.type,
+            start_command,
+            inject_serve: Boolean(framework.injectServe),
+        };
+    }
+    return { type: framework.type, start_command: null, inject_serve: false };
+};
+
+export { FRAMEWORKS, detect_framework, resolve_angular_output };

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

@@ -1,6 +1,7 @@
 import { build_docker } from './build_docker.js';
 import { analyze_package } from './analyze_package.js';
 import { build_project } from './build_project.js';
+import { inject_serve } from './inject_serve.js';
 import * as R from 'ramda';
 import { log } from '../../../log.js';
 
@@ -11,16 +12,24 @@ const build_node = async (app, options) => {
         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 });
+    const { build_script, type, start_command, inject_serve: needs_serve } = await analyze_package({
+        workdir,
+    });
     // Environment variables
     const env = R.fromPairs(env_vars.map((e) => [e.name, e.value]));
     log.info(`Building with env variables ${Object.keys(env).join(",")}`);
     // Do build
     await build_project({ build_script, env });
+    // Frameworks without a bundled static server (CRA/Vue/Angular) need `serve`
+    // installed into node_modules before packaging, so it ships in the image.
+    if (needs_serve) {
+        await inject_serve(workdir);
+    }
     // Bundle project inside a docker image
     await build_docker({
         app,
         workdir,
+        start_command,
         template_context: {
             from: `node:${runtime.version}`,
         },

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

@@ -0,0 +1,20 @@
+import { log } from '../../../log.js';
+import { cmd } from '../../../lib/cmd.js';
+
+// Pinned for reproducible builds. `serve` is the standalone static server used
+// for frameworks without a bundled preview tool (CRA, Vue, Angular).
+const SERVE_VERSION = "14";
+/**
+ * Install `serve` into the project's node_modules so it ships inside the image
+ * via `COPY . .` (the Dockerfile does no `npm install`). This lets `npx serve`
+ * resolve the local copy at container start — no runtime download needed.
+ *
+ * `--no-save` keeps the user's package.json/lockfile untouched.
+ */
+const inject_serve = async (workdir) => {
+    log.info(`📥 Injecting static server (serve@${SERVE_VERSION}) into image`);
+    const timeout = 5 * 60 * 1000; // 5 minute timeout
+    await cmd(`npm install serve@${SERVE_VERSION} --no-save --no-audit --no-fund`, { cwd: workdir, timeout, enableOutput: true });
+};
+
+export { inject_serve };

package/dist/lib/Configuration.js

@@ -38,6 +38,10 @@ class Configuration {
     get startCommand() {
         return this.config.startCommand || "npm run start";
     }
+    /** Start command explicitly set in faable.json, or undefined when relying on the default. */
+    get configuredStartCommand() {
+        return this.config.startCommand;
+    }
     get buildCommand() {
         return this.config.buildCommand;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@faable/faable",
-  "version": "1.5.27",
+  "version": "1.5.28",
   "main": "dist/index.js",
   "license": "MIT",
   "author": "Marc Pomar <marc@faable.com>",