@flisk-sh/flisk-import 0.4.0 → 0.4.1

package/README.md

@@ -32,7 +32,7 @@ flisk import tiltfile dev/Tiltfile --yes # a named file, or a folder that holds
 
 - **Path:** `[path]` defaults to `Tiltfile`; a folder means `<folder>/Tiltfile`. It is resolved from the current directory. The project root is the nearest folder with `.flisk/project.json`, else the current directory.
 - **Writes:** only `.flisk/project.json`, with `"orchestration": { "source": "tiltfile", "path": "<path from the project root>" }`. Every other key is kept. Without a `project.json`, it creates the same minimal one as the Compose import, with only the proxy stack. It never edits the Tiltfile.
-- **Refuses (exit 1):** a missing Tiltfile, a path inside `.flisk/`, a path with a quote or control character, and a `project.json` that already sets `orchestration` (pass `--force` to replace it).
+- **Refuses (exit 1):** a missing Tiltfile, a path inside `.flisk/` (also through a symlink), a path with a quote or control character, a `project.json` that is not a JSON object or lacks the fields `flisk up` needs, and a `project.json` that already sets `orchestration` (pass `--force` to replace it).
 - **Exit codes:** the same as the Compose import: `0` for `--dry-run` or a write, `1` for a refusal, `2` when the prompt is declined or closed (`Nothing written.`).
 - **Needs** a Flisk core that runs an imported Tiltfile ([flisk#2849](https://github.com/flisk-sh/flisk/pull/2849)). The importer does not check the core version.
 

package/dist/flisk.js

@@ -70,3 +70,52 @@ export function defaultProjectConfig(projectRoot, preAlpha) {
         overrides: {},
     };
 }
+const isObject = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+const PHASES = ["pre_alpha", "alpha", "beta", "out_of_scope"];
+const OPTIONAL_INFRA = ["monitoring", "elk", "debezium", "golden_image", "verdaccio"];
+/**
+ * The fields of an existing `.flisk/project.json` that Flisk core would refuse, missing or of the wrong type, as dotted
+ * names such as `project.name`. A whole object that is absent is named once (`optional_infra`), not field by field.
+ * Empty when `flisk up` can read the file. A copy of core's `normalizeProjectConfig` (flisk
+ * `cli/src/generator/template-engine.ts`), so it can drift from flisk.
+ */
+export function missingProjectFields(config) {
+    const missing = [];
+    if (typeof config.version !== "string")
+        missing.push("version");
+    if (!isObject(config.project))
+        missing.push("project");
+    else
+        for (const key of ["name", "version"])
+            if (typeof config.project[key] !== "string")
+                missing.push(`project.${key}`);
+    // Core also reads the older `stacks` shape, with `services` in place of `enabledStacks`.
+    const phaseGaps = (value, label, field) => {
+        if (!isObject(value))
+            return [label];
+        return PHASES.filter((phase) => {
+            const entry = value[phase];
+            return !isObject(entry) || !Array.isArray(entry[field]);
+        }).map((phase) => `${label}.${phase}.${field}`);
+    };
+    const phases = phaseGaps(config.phases, "phases", "enabledStacks");
+    if (phases.length && phaseGaps(config.stacks, "stacks", "services").length)
+        missing.push(...phases);
+    if (!isObject(config.optional_infra))
+        missing.push("optional_infra");
+    else {
+        const infra = config.optional_infra;
+        for (const key of OPTIONAL_INFRA)
+            if (typeof infra[key] !== "boolean")
+                missing.push(`optional_infra.${key}`);
+    }
+    if (!isObject(config.discovery))
+        missing.push("discovery");
+    else if (!Array.isArray(config.discovery.paths))
+        missing.push("discovery.paths");
+    if (config.capabilities !== undefined &&
+        !(isObject(config.capabilities) &&
+            Object.values(config.capabilities).every((flag) => typeof flag === "boolean")))
+        missing.push("capabilities");
+    return missing;
+}

package/dist/tiltfile.js

@@ -1,8 +1,29 @@
-import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
-import { dirname, join, relative, resolve } from "node:path";
+import { existsSync, mkdirSync, readFileSync, realpathSync, statSync, writeFileSync, } from "node:fs";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { ImportError } from "./errors.js";
-import { defaultProjectConfig, findProjectRoot } from "./flisk.js";
+import { defaultProjectConfig, findProjectRoot, missingProjectFields } from "./flisk.js";
 const RERUN = "flisk import tiltfile <path>";
+const RECREATE = "Or recreate it with `flisk project --yes --force` (this resets .flisk/project.json), then run the import again";
+/** The refusal for a Tiltfile inside `.flisk/`; `resolved` names where a symlink leads. */
+function insideFliskError(path, resolved) {
+    const via = resolved ? ` (it resolves to ${resolved})` : "";
+    return new ImportError(`${path} is inside .flisk/${via}, where Flisk writes its generated files; import your own Tiltfile instead`, [`Point it at the Tiltfile you maintain: ${RERUN}`]);
+}
+/**
+ * Where `tiltfile` really is, relative to the real `<projectRoot>/.flisk`, when a symlink on the way leads into it.
+ * The lexical check misses `infra/Tiltfile -> ../.flisk/.flisk-out/Tiltfile`, and flisk up would then include its own
+ * generated Tiltfile. Undefined when it does not, or when there is no `.flisk/` yet.
+ */
+function linkedIntoFlisk(tiltfile, projectRoot) {
+    const fliskDir = join(projectRoot, ".flisk");
+    if (!existsSync(fliskDir))
+        return undefined;
+    const realFlisk = realpathSync(fliskDir);
+    const inside = relative(realFlisk, realpathSync(tiltfile));
+    if (inside === ".." || inside.startsWith(`..${sep}`) || isAbsolute(inside))
+        return undefined;
+    return [".flisk", ...inside.split(sep)].join("/");
+}
 /** Describes an `orchestration` value for a message, for example `tiltfile: Tiltfile`. */
 export function describeOrchestration(value) {
     if (value && typeof value === "object" && "source" in value) {
@@ -30,14 +51,16 @@ export function planTiltfileImport(pathArg = "Tiltfile", options = {}) {
     if (hasUnsafeChar(path)) {
         throw new ImportError(`Tiltfile path ${JSON.stringify(path)} has a quote or control character`, ["Rename the file or folder, then run: flisk import tiltfile <path>"]);
     }
-    if (path === ".flisk" || path.startsWith(".flisk/")) {
-        throw new ImportError(`${path} is inside .flisk/, where Flisk writes its generated files; import your own Tiltfile instead`, [`Point it at the Tiltfile you maintain: ${RERUN}`]);
-    }
+    if (path === ".flisk" || path.startsWith(".flisk/"))
+        throw insideFliskError(path);
     if (!statSync(tiltfile, { throwIfNoEntry: false })?.isFile()) {
         throw new ImportError(`No Tiltfile found at ${pathArg}`, [
             `Pass the path of an existing Tiltfile, or a folder that holds one: ${RERUN}`,
         ]);
     }
+    const resolved = linkedIntoFlisk(tiltfile, projectRoot);
+    if (resolved)
+        throw insideFliskError(path, resolved);
     const projectJson = join(projectRoot, ".flisk", "project.json");
     const orchestration = { source: "tiltfile", path };
     if (!existsSync(projectJson)) {
@@ -62,14 +85,23 @@ export function planTiltfileImport(pathArg = "Tiltfile", options = {}) {
         existing = JSON.parse(readFileSync(projectJson, "utf8"));
     }
     catch (err) {
-        throw new ImportError(`Cannot read ${projectJson}: ${err instanceof Error ? err.message : String(err)}`, ["Fix the JSON in .flisk/project.json, then run the import again"]);
+        throw new ImportError(`Cannot read ${projectJson}: ${err instanceof Error ? err.message : String(err)}`, ["Fix the JSON in .flisk/project.json, then run the import again", RECREATE]);
     }
     if (!existing || typeof existing !== "object" || Array.isArray(existing)) {
         throw new ImportError(`${projectJson} is not a JSON object`, [
             "Fix .flisk/project.json, then run the import again",
+            RECREATE,
         ]);
     }
     const config = existing;
+    // Writing orchestration into a file flisk up cannot read would report success and then fail at flisk up.
+    const missing = missingProjectFields(config);
+    if (missing.length) {
+        throw new ImportError(`.flisk/project.json is missing fields flisk up needs, or has them with the wrong type: ${missing.join(", ")}`, [
+            `Add ${missing.length === 1 ? "it" : "them"} to .flisk/project.json, then run the import again`,
+            RECREATE,
+        ]);
+    }
     const replaced = config.orchestration;
     if (replaced !== undefined && !options.force) {
         throw new ImportError(`.flisk/project.json already sets orchestration (${describeOrchestration(replaced)})`, ["Pass --force to replace it; every other key is kept"]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flisk-sh/flisk-import",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Import a repository's root docker-compose.yml into Flisk service.json files, or register its Tiltfile.",
   "type": "module",
   "license": "MIT",