elm-pages 3.0.26 → 3.0.28

package/generator/dead-code-review/src/Pages/Review/DeadCodeEliminateData.elm

@@ -145,7 +145,7 @@ declarationVisitor node context =
                                             (\recordSetter ->
                                                 case Node.value recordSetter of
                                                     ( keyNode, valueNode ) ->
-                                                        if Node.value keyNode == "data" || Node.value keyNode == "action" then
+                                                        if Node.value keyNode == "data" || Node.value keyNode == "action" || Node.value keyNode == "pages" then
                                                             if isAlreadyApplied context.lookupTable (Node.value valueNode) then
                                                                 Nothing
 
@@ -203,7 +203,7 @@ expressionVisitor node context =
                                     (\recordSetter ->
                                         case Node.value recordSetter of
                                             ( keyNode, valueNode ) ->
-                                                if Node.value keyNode == "data" || Node.value keyNode == "action" then
+                                                if Node.value keyNode == "data" || Node.value keyNode == "action" || Node.value keyNode == "pages" then
                                                     if isAlreadyApplied context.lookupTable (Node.value valueNode) then
                                                         Nothing
 
@@ -234,16 +234,28 @@ expressionVisitor node context =
                                             ++ " = "
                                             ++ (case pageBuilderName of
                                                     "preRender" ->
-                                                        "\\_ -> "
-                                                            ++ referenceFunction context.importContext ( [ "BackendTask" ], "fail" )
-                                                            ++ " "
-                                                            ++ exceptionFromString
+                                                        if key == "pages" then
+                                                            referenceFunction context.importContext ( [ "BackendTask" ], "fail" )
+                                                                ++ " "
+                                                                ++ exceptionFromString
+
+                                                        else
+                                                            "\\_ -> "
+                                                                ++ referenceFunction context.importContext ( [ "BackendTask" ], "fail" )
+                                                                ++ " "
+                                                                ++ exceptionFromString
 
                                                     "preRenderWithFallback" ->
-                                                        "\\_ -> "
-                                                            ++ referenceFunction context.importContext ( [ "BackendTask" ], "fail" )
-                                                            ++ " "
-                                                            ++ exceptionFromString
+                                                        if key == "pages" then
+                                                            referenceFunction context.importContext ( [ "BackendTask" ], "fail" )
+                                                                ++ " "
+                                                                ++ exceptionFromString
+
+                                                        else
+                                                            "\\_ -> "
+                                                                ++ referenceFunction context.importContext ( [ "BackendTask" ], "fail" )
+                                                                ++ " "
+                                                                ++ exceptionFromString
 
                                                     "serverRender" ->
                                                         "\\_ _ -> "

package/generator/dead-code-review/tests/Pages/Review/DeadCodeEliminateDataTest.elm

@@ -311,7 +311,7 @@ route =
     RouteBuilder.preRender
         { data = data
         , head = head
-        , pages = pages
+        , pages = BackendTask.fail (FatalError.fromString "")
         }
         |> RouteBuilder.buildNoState { view = view }
 
@@ -366,7 +366,7 @@ route =
     RouteBuilder.preRender
         { data = \\_ -> BackendTask.fail (FatalError.fromString "")
         , head = head
-        , pages = pages
+        , pages = BackendTask.fail (FatalError.fromString "")
         }
         |> RouteBuilder.buildNoState { view = view }
 
@@ -374,6 +374,109 @@ route =
 data : BackendTask Data
 data =
     BackendTask.succeed ()
+"""
+                        ]
+        , test "replaces pages record setter in preRender" <|
+            \() ->
+                """module Route.Blog.Slug_ exposing (Data, Model, Msg, route)
+
+import Server.Request as Request
+
+import BackendTask exposing (BackendTask)
+import FatalError
+import RouteBuilder exposing (Page, App)
+import Pages.PageUrl exposing (PageUrl)
+import Pages.Url
+import UrlPath
+import Route exposing (Route)
+import Shared
+import View exposing (View)
+
+
+type alias Model =
+   {}
+
+
+type alias Msg =
+   ()
+
+
+type alias RouteParams =
+    { slug : String }
+
+
+type alias Data =
+   ()
+
+
+route : StatelessRoute RouteParams Data ActionData
+route =
+    RouteBuilder.preRender
+        { data = \\_ -> BackendTask.fail (FatalError.fromString "")
+        , head = head
+        , pages = pages
+        }
+        |> RouteBuilder.buildNoState { view = view }
+
+
+pages : BackendTask (List RouteParams)
+pages =
+    BackendTask.succeed [ { slug = "hello" } ]
+"""
+                    |> Review.Test.run rule
+                    |> Review.Test.expectErrors
+                        [ Review.Test.error
+                            { message = "Codemod"
+                            , details =
+                                [ "" ]
+                            , under =
+                                """pages = pages
+        }"""
+                            }
+                            |> Review.Test.whenFixed
+                                """module Route.Blog.Slug_ exposing (Data, Model, Msg, route)
+
+import Server.Request as Request
+
+import BackendTask exposing (BackendTask)
+import FatalError
+import RouteBuilder exposing (Page, App)
+import Pages.PageUrl exposing (PageUrl)
+import Pages.Url
+import UrlPath
+import Route exposing (Route)
+import Shared
+import View exposing (View)
+
+
+type alias Model =
+   {}
+
+
+type alias Msg =
+   ()
+
+
+type alias RouteParams =
+    { slug : String }
+
+
+type alias Data =
+   ()
+
+
+route : StatelessRoute RouteParams Data ActionData
+route =
+    RouteBuilder.preRender
+        { data = \\_ -> BackendTask.fail (FatalError.fromString "")
+        , head = head
+        , pages = BackendTask.fail (FatalError.fromString "")}
+        |> RouteBuilder.buildNoState { view = view }
+
+
+pages : BackendTask (List RouteParams)
+pages =
+    BackendTask.succeed [ { slug = "hello" } ]
 """
                         ]
         , test "replaces data record setter with RouteBuilder.serverRendered" <|

package/generator/review/elm.json

@@ -12,7 +12,7 @@
             "elm/json": "1.1.3",
             "elm/regex": "1.0.0",
             "jfmengels/elm-review": "2.15.1",
-            "mdgriffith/elm-codegen": "5.2.0",
+            "mdgriffith/elm-codegen": "6.0.1",
             "stil4m/elm-syntax": "7.3.8",
             "the-sett/elm-syntax-dsl": "6.0.3"
         },

package/generator/src/compatibility-key.js

@@ -1,3 +1,3 @@
-export const compatibilityKey = 22;
+export const compatibilityKey = 23;
 
-export const packageVersion = "3.0.26";
+export const packageVersion = "3.0.28";

package/generator/src/render.js

@@ -536,6 +536,8 @@ async function runInternalJob(
         return [requestHash, await runWhich(requestToPerform)];
       case "elm-pages-internal://question":
         return [requestHash, await runQuestion(requestToPerform)];
+      case "elm-pages-internal://readKey":
+        return [requestHash, await runReadKey(requestToPerform)];
       case "elm-pages-internal://shell":
         return [requestHash, await runShell(requestToPerform)];
       case "elm-pages-internal://stream":
@@ -638,6 +640,10 @@ async function runQuestion(req) {
   return jsonResponse(req, await question(req.body.args[0]));
 }
 
+async function runReadKey(req) {
+  return jsonResponse(req, await readKey());
+}
+
 function runStream(req, portsFile) {
   return new Promise(async (resolve) => {
     const context = getContext(req);
@@ -667,19 +673,21 @@ function runStream(req, portsFile) {
         index += 1;
       }
       if (kind === "json") {
-        resolve(
-          jsonResponse(req, {
-            body: await consumers.json(lastStream),
-            metadata: await tryCallingFunction(metadataResponse),
-          })
-        );
+        try {
+          const body = await consumers.json(lastStream);
+          const metadata = await tryCallingFunction(metadataResponse);
+          resolve(jsonResponse(req, { body, metadata }));
+        } catch (error) {
+          resolve(jsonResponse(req, { error: error.toString() }));
+        }
       } else if (kind === "text") {
-        resolve(
-          jsonResponse(req, {
-            body: await consumers.text(lastStream),
-            metadata: await tryCallingFunction(metadataResponse),
-          })
-        );
+        try {
+          const body = await consumers.text(lastStream);
+          const metadata = await tryCallingFunction(metadataResponse);
+          resolve(jsonResponse(req, { body, metadata }));
+        } catch (error) {
+          resolve(jsonResponse(req, { error: error.toString() }));
+        }
       } else if (kind === "none") {
         if (!lastStream) {
           // ensure all error handling gets a chance to fire before resolving successfully
@@ -687,22 +695,21 @@ function runStream(req, portsFile) {
           resolve(jsonResponse(req, { body: null }));
         } else {
           let resolvedMeta = await tryCallingFunction(metadataResponse);
-          lastStream.once("finish", async () => {
+          // Writable streams emit "finish", Readable streams emit "end"
+          // Duplex streams emit both - use a flag to prevent double-resolve
+          let resolved = false;
+          const onComplete = () => {
+            if (resolved) return;
+            resolved = true;
             resolve(
               jsonResponse(req, {
                 body: null,
                 metadata: resolvedMeta,
               })
             );
-          });
-          lastStream.once("end", async () => {
-            resolve(
-              jsonResponse(req, {
-                body: null,
-                metadata: resolvedMeta,
-              })
-            );
-          });
+          };
+          lastStream.once("finish", onComplete);
+          lastStream.once("end", onComplete);
         }
       } else if (kind === "command") {
         // already handled in parts.forEach
@@ -745,19 +752,36 @@ function runStream(req, portsFile) {
             env,
           });
           if (validateStream.isDuplexStream(newLocal.stream)) {
+            newLocal.stream.once("error", (error) => {
+              newLocal.stream.destroy();
+              resolve({ error: `Custom duplex stream '${part.portName}' error: ${error.message}` });
+            });
             pipeIfPossible(lastStream, newLocal.stream);
+            if (!lastStream) {
+              endStreamIfNoInput(newLocal.stream);
+            }
             return newLocal;
           } else {
             throw `Expected '${part.portName}' to be a duplex stream!`;
           }
         } else if (part.name === "customRead") {
+          const newLocal = await portsFile[part.portName](part.input, {
+            cwd,
+            quiet,
+            env,
+          });
+          // customRead can return either a stream directly or { stream, metadata }
+          const stream = newLocal.stream || newLocal;
+          if (!validateStream.isReadableStream(stream)) {
+            throw `Expected '${part.portName}' to return a readable stream!`;
+          }
+          stream.once("error", (error) => {
+            stream.destroy();
+            resolve({ error: `Custom read stream '${part.portName}' error: ${error.message}` });
+          });
           return {
-            metadata: null,
-            stream: await portsFile[part.portName](part.input, {
-              cwd,
-              quiet,
-              env,
-            }),
+            metadata: newLocal.metadata || null,
+            stream: stream,
           };
         } else if (part.name === "customWrite") {
           const newLocal = await portsFile[part.portName](part.input, {
@@ -766,25 +790,42 @@ function runStream(req, portsFile) {
             env,
           });
           if (!validateStream.isWritableStream(newLocal.stream)) {
-            console.error("Expected a writable stream!");
-            resolve({ error: "Expected a writable stream!" });
-          } else {
-            pipeIfPossible(lastStream, newLocal.stream);
+            throw `Expected '${part.portName}' to return a writable stream!`;
+          }
+          newLocal.stream.once("error", (error) => {
+            newLocal.stream.destroy();
+            resolve({ error: `Custom write stream '${part.portName}' error: ${error.message}` });
+          });
+          pipeIfPossible(lastStream, newLocal.stream);
+          if (!lastStream) {
+            endStreamIfNoInput(newLocal.stream);
           }
           return newLocal;
         } else if (part.name === "gzip") {
           const gzip = zlib.createGzip();
+          gzip.once("error", (error) => {
+            gzip.destroy();
+            resolve({ error: `gzip error: ${error.message}` });
+          });
           if (!lastStream) {
-            gzip.end();
+            endStreamIfNoInput(gzip);
           }
           return {
             metadata: null,
             stream: pipeIfPossible(lastStream, gzip),
           };
         } else if (part.name === "unzip") {
+          const unzip = zlib.createUnzip();
+          unzip.once("error", (error) => {
+            unzip.destroy();
+            resolve({ error: `unzip error: ${error.message}` });
+          });
+          if (!lastStream) {
+            endStreamIfNoInput(unzip);
+          }
           return {
             metadata: null,
-            stream: pipeIfPossible(lastStream, zlib.createUnzip()),
+            stream: pipeIfPossible(lastStream, unzip),
           };
         } else if (part.name === "fileWrite") {
           const destinationPath = path.resolve(part.path);
@@ -801,9 +842,13 @@ function runStream(req, portsFile) {
             newLocal.removeAllListeners();
             resolve({ error: error.toString() });
           });
+          pipeIfPossible(lastStream, newLocal);
+          if (!lastStream) {
+            endStreamIfNoInput(newLocal);
+          }
           return {
             metadata: null,
-            stream: pipeIfPossible(lastStream, newLocal),
+            stream: newLocal,
           };
         } else if (part.name === "httpWrite") {
           const makeFetchHappen = makeFetchHappenOriginal.defaults({
@@ -865,6 +910,9 @@ function runStream(req, portsFile) {
           });
 
           pipeIfPossible(lastStream, newProcess.stdin);
+          if (!lastStream) {
+            endStreamIfNoInput(newProcess.stdin);
+          }
           let newStream;
           if (output === "MergeWithStdout") {
             newStream = mergeStreams([newProcess.stdout, newProcess.stderr]);
@@ -874,28 +922,40 @@ function runStream(req, portsFile) {
             newStream = newProcess.stdout;
           }
 
+          // For the last process, we need to track metadata resolution
+          // so we can resolve it even if the process errors
+          let resolveMeta = null;
+          const metadataPromise = isLastProcess
+            ? new Promise((resolve) => {
+                resolveMeta = resolve;
+              })
+            : null;
+
           newProcess.once("error", (error) => {
             newStream && newStream.end();
             newProcess.removeAllListeners();
+            // Resolve metadata Promise to prevent hanging awaits
+            if (resolveMeta) {
+              resolveMeta({ exitCode: null, error: error.toString() });
+            }
             resolve({ error: error.toString() });
           });
+
           if (isLastProcess) {
+            newProcess.once("exit", (code) => {
+              if (code !== 0 && !allowNon0Status) {
+                newStream && newStream.end();
+                resolve({
+                  error: `Command ${command} exited with code ${code}`,
+                });
+              }
+              resolveMeta({
+                exitCode: code,
+              });
+            });
             return {
               stream: newStream,
-              metadata: new Promise((resoveMeta) => {
-                newProcess.once("exit", (code) => {
-                  if (code !== 0 && !allowNon0Status) {
-                    newStream && newStream.end();
-                    resolve({
-                      error: `Command ${command} exited with code ${code}`,
-                    });
-                  }
-
-                  resoveMeta({
-                    exitCode: code,
-                  });
-                });
-              }),
+              metadata: metadataPromise,
             };
           } else {
             return { metadata: null, stream: newStream };
@@ -930,6 +990,45 @@ function pipeIfPossible(input, destination) {
   }
 }
 
+/**
+ * Safely signals EOF to a writable stream when no input will be piped to it.
+ *
+ * This is necessary because when a writable stream (like a child process's stdin)
+ * is created but nothing is piped to it, the receiving end has no way to know
+ * that no data is coming. It will wait indefinitely for the pipe to close.
+ *
+ * GUI applications like ksdiff/meld are particularly affected - they wait for
+ * stdin to close before proceeding, causing hangs if we don't explicitly end it.
+ *
+ * @param {import('stream').Writable | null | undefined} stream - The writable stream to end
+ */
+function endStreamIfNoInput(stream) {
+  if (!stream) {
+    return;
+  }
+
+  // Check if stream is still in a state where .end() is valid
+  // - writable: false if the stream has been destroyed or ended
+  // - writableEnded: true if .end() has already been called
+  // - destroyed: true if .destroy() has been called
+  if (!stream.writable || stream.writableEnded || stream.destroyed) {
+    return;
+  }
+
+  // Add a one-time error handler to prevent unhandled error crashes
+  // This can happen if the child process exits before we call .end()
+  stream.once("error", (err) => {
+    // EPIPE: "broken pipe" - the other end closed before we finished
+    // This is expected if the child process exits quickly
+    if (err.code !== "EPIPE") {
+      // Log unexpected errors but don't crash - this is cleanup code
+      console.error("Stream end error:", err.message);
+    }
+  });
+
+  stream.end();
+}
+
 function stdout() {
   return new Writable({
     write(chunk, encoding, callback) {
@@ -1077,7 +1176,7 @@ export function pipeShells(
       if (previousProcess === null) {
         currentProcess = spawnCallback(command, args, {
           stdio: ["inherit", "pipe", "inherit"],
-          timeout: timeout ? undefined : timeout,
+          timeout: timeout,
           cwd: cwd,
           env: env,
         });
@@ -1087,14 +1186,14 @@ export function pipeShells(
             stdio: quiet
               ? ["pipe", "ignore", "ignore"]
               : ["pipe", "inherit", "inherit"],
-            timeout: timeout ? undefined : timeout,
+            timeout: timeout,
             cwd: cwd,
             env: env,
           });
         } else {
           currentProcess = spawnCallback(command, args, {
             stdio: ["pipe", "pipe", "pipe"],
-            timeout: timeout ? undefined : timeout,
+            timeout: timeout,
             cwd: cwd,
             env: env,
           });
@@ -1153,6 +1252,48 @@ export async function question({ prompt }) {
   });
 }
 
+/**
+ * Read a single keypress from stdin without requiring Enter.
+ * Uses raw mode to capture individual keypresses.
+ * Falls back to line-buffered input when not in a TTY (e.g., piped input).
+ */
+export async function readKey() {
+  const stdin = process.stdin;
+
+  if (!stdin.isTTY) {
+    // Fall back to reading a line when not in a TTY (piped input, CI, etc.)
+    // Takes the first character of the input line
+    const rl = readline.createInterface({ input: stdin });
+    return new Promise((resolve) => {
+      rl.once("line", (line) => {
+        rl.close();
+        resolve(line.charAt(0) || "\n");
+      });
+    });
+  }
+
+  // TTY mode - single keypress without Enter
+  return new Promise((resolve) => {
+    const wasRaw = stdin.isRaw;
+
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+
+    stdin.once("data", (key) => {
+      stdin.setRawMode(wasRaw);
+      stdin.pause();
+
+      // Handle Ctrl+C to exit gracefully
+      if (key === "\u0003") {
+        process.exit();
+      }
+
+      resolve(key);
+    });
+  });
+}
+
 async function runWriteFileJob(req) {
   const { cwd } = getContext(req);
   const data = req.body.args[0];
@@ -1223,7 +1364,7 @@ async function runGlobNew(req, patternsToWatch) {
         }
         return {
           fullPath: fullPath.path,
-          captures: mm.capture(pattern, fullPath.path),
+          captures: mm.capture(pattern, fullPath.path) || [],
           fileStats: {
             size: stats.size,
             atime: Math.round(stats.atime.getTime()),

package/generator/template/elm.json

@@ -31,7 +31,7 @@
             "elm-community/result-extra": "2.4.0",
             "jluckyiv/elm-utc-date-strings": "1.0.0",
             "justinmimbs/date": "4.1.0",
-            "mdgriffith/elm-codegen": "5.2.0",
+            "mdgriffith/elm-codegen": "6.0.1",
             "miniBill/elm-codec": "2.2.0",
             "noahzgordon/elm-color-extra": "1.0.2",
             "robinheghan/fnv1a": "1.0.0",

package/generator/template/script/elm.json

@@ -13,7 +13,7 @@
             "elm/core": "1.0.5",
             "elm/html": "1.0.0",
             "elm/json": "1.1.3",
-            "mdgriffith/elm-codegen": "5.2.0"
+            "mdgriffith/elm-codegen": "6.0.1"
         },
         "indirect": {
             "Chadtech/elm-bool-extra": "2.4.2",