elm-ssr 0.6.1 → 0.90.0

package/bin/elm-ssr.mjs

@@ -3,10 +3,11 @@
 import { readFile, stat } from "node:fs/promises";
 import { watch } from "node:fs";
 import { dirname, resolve } from "node:path";
-import { createAppScaffold } from "../lib/scaffold.mjs";
+import { createAppScaffold, createRouteScaffold } from "../lib/scaffold.mjs";
 import { readWorkspaceConfig } from "../lib/workspace.mjs";
 import { build } from "../lib/build.mjs";
 import { migrate } from "../lib/migrate.mjs";
+import { generateQueries } from "../lib/query.mjs";
 
 const defaultRootPath = process.cwd();
 const args = process.argv.slice(2);
@@ -36,7 +37,14 @@ const findWorkspaceRoot = async (startPath) => {
 };
 
 const userRoot = findFlagValue("--root");
-const rootPath = resolve(userRoot ?? await findWorkspaceRoot(defaultRootPath));
+let rootPath;
+if (userRoot) {
+  rootPath = resolve(userRoot);
+} else if (["new", "init", "migrate", "help"].includes(command)) {
+  rootPath = defaultRootPath;
+} else {
+  rootPath = resolve(await findWorkspaceRoot(defaultRootPath));
+}
 const packageJsonPath = resolve(rootPath, "package.json");
 
 let packageJson = { name: "unknown" };
@@ -72,6 +80,8 @@ const printHelp = () => {
   new <name>    Create a new app at <workspace>/<name>/ (or <workspace>/<subdir>/<name>/
                 with --in <subdir>) and register it in elm-ssr.config.json
   routes        Print configured apps and their public modules
+  route <path>  Scaffold a new route (standard HTML, --api JSON, --ws WebSocket, or --sse EventSource)
+  query         Generate type-safe Elm Db modules from SQL table definitions
   info          Print current workspace package and configured app names
   migrate ...   Apply / revert / inspect SQL migrations (see: elm-ssr migrate --help)
 `);
@@ -128,7 +138,7 @@ switch (command) {
       const srcDir = resolve(rootPath, app.root, "src");
       try {
         const watcher = watch(srcDir, { recursive: true }, (eventType, filename) => {
-          if (filename && filename.endsWith(".elm")) {
+          if (filename && (filename.endsWith(".elm") || filename.endsWith(".css"))) {
             triggerBuild();
           }
         });
@@ -218,12 +228,82 @@ switch (command) {
     }
     break;
 
+  case "route": {
+    requireConfig();
+    const routePath = args[1];
+    if (!routePath) {
+      console.error("Usage: elm-ssr route <path> [--app <app-name>] [--api] [--ws] [--sse]");
+      process.exit(1);
+    }
+    
+    const appName = findFlagValue("--app");
+    let appConfig;
+    if (appName) {
+      appConfig = config.apps.find(a => a.name === appName);
+      if (!appConfig) {
+        console.error(`Error: App "${appName}" not found in elm-ssr.config.json`);
+        process.exit(1);
+      }
+    } else {
+      if (config.apps.length === 1) {
+        appConfig = config.apps[0];
+      } else {
+        console.error("Error: Multiple apps found in workspace config. Please specify which app to add the route to using --app <app-name>");
+        console.error("Available apps:", config.apps.map(a => a.name).join(", "));
+        process.exit(1);
+      }
+    }
+
+    const isApi = args.includes("--api");
+    const isWs = args.includes("--ws") || args.includes("--websocket");
+    const isSse = args.includes("--sse");
+
+    const result = await createRouteScaffold(rootPath, appConfig, routePath, { isApi, isWs, isSse });
+    console.log(`Scaffolded ${result.type} route at ${result.path}`);
+    if (result.instructions) {
+      console.log("\nInstructions to wire it up:\n" + result.instructions);
+    }
+    break;
+  }
+
   case "info":
     requireConfig();
     console.log(`workspace: ${packageJson.name}`);
     console.log(`apps: ${config.apps.map((app) => app.name).join(", ")}`);
     break;
 
+  case "query": {
+    requireConfig();
+    const appName = findFlagValue("--app");
+    let appConfig;
+    if (appName) {
+      appConfig = config.apps.find(a => a.name === appName);
+      if (!appConfig) {
+        console.error(`Error: App "${appName}" not found in elm-ssr.config.json`);
+        process.exit(1);
+      }
+    } else {
+      if (config.apps.length === 1) {
+        appConfig = config.apps[0];
+      } else {
+        console.error("Error: Multiple apps found in workspace config. Please specify which app to query using --app <app-name>");
+        console.error("Available apps:", config.apps.map(a => a.name).join(", "));
+        process.exit(1);
+      }
+    }
+
+    const migrationsDir = findFlagValue("--dir");
+    const outputDir = findFlagValue("--output");
+
+    try {
+      await generateQueries({ rootPath, appConfig, migrationsDir, outputDir });
+    } catch (err) {
+      console.error(`Error generating query modules: ${err.message}`);
+      process.exit(1);
+    }
+    break;
+  }
+
   case "migrate":
     await migrate(args.slice(1));
     break;

package/elm-src/ElmSsr/Action.elm

@@ -1,6 +1,6 @@
 module ElmSsr.Action exposing
     ( Action
-    , succeed, fail, redirect, json
+    , succeed, fail, redirect, json, requireUser
     , map, andThen, fromLoader
     , Cookie, SameSite(..), setCookie, clearCookie, defaultCookie, sessionCookie
     , Effect, Step(..), step, collectCookies, encodeStep, encodeCookies
@@ -225,6 +225,21 @@ json =
     JsonResult
 
 
+{-| Require a user session for an action. If missing, redirect to the login path. -}
+requireUser : Decode.Decoder user -> String -> (user -> Action a) -> Action a
+requireUser userDecoder loginPath toAction =
+    fromLoader (Loader.session userDecoder)
+        |> andThen
+            (\maybeUser ->
+                case maybeUser of
+                    Just user ->
+                        toAction user
+
+                    Nothing ->
+                        redirect loginPath
+            )
+
+
 {-| Transform the value an action resolves to. -}
 map : (a -> b) -> Action a -> Action b
 map fn action =
@@ -284,6 +299,9 @@ fromLoader loader =
         Loader.Errored status message ->
             Failed status message
 
+        Loader.Moved url ->
+            Redirect url
+
         Loader.Await effect continue ->
             Pending effect (\value -> fromLoader (continue value))
 

package/elm-src/ElmSsr/Db/Dsl.elm

@@ -0,0 +1,223 @@
+module ElmSsr.Db.Dsl exposing
+    ( Table, table
+    , Column, column
+    , AnyColumn, col
+    , Expression
+    , Query
+    , select, selectAll
+    , where_, limit
+    , eq, neq, gt, gte, lt, lte, like, inList
+    , isNull, isNotNull
+    , and, or
+    , toLoader, toLoaderOne
+    , compileQuery
+    )
+
+import Json.Decode as Decode exposing (Decoder)
+import Json.Encode as Encode
+import ElmSsr.Loader as Loader exposing (Loader)
+
+
+type Table table
+    = Table String
+
+
+table : String -> Table table
+table name =
+    Table name
+
+
+type Column table val
+    = Column String (val -> Encode.Value)
+
+
+column : String -> (val -> Encode.Value) -> Column table val
+column name encoder =
+    Column name encoder
+
+
+type AnyColumn table
+    = AnyColumn String
+
+
+col : Column table val -> AnyColumn table
+col (Column name _) =
+    AnyColumn name
+
+
+type Expression table
+    = Expression String (List Encode.Value)
+
+
+type Query table a
+    = Query
+        { tableName : String
+        , selection : List String
+        , conditions : List (Expression table)
+        , limitVal : Maybe Int
+        , decoder : Decoder a
+        }
+
+
+eq : val -> Column table val -> Expression table
+eq val (Column colName encoder) =
+    Expression (colName ++ " = ?") [ encoder val ]
+
+
+neq : val -> Column table val -> Expression table
+neq val (Column colName encoder) =
+    Expression (colName ++ " != ?") [ encoder val ]
+
+
+gt : val -> Column table val -> Expression table
+gt val (Column colName encoder) =
+    Expression (colName ++ " > ?") [ encoder val ]
+
+
+gte : val -> Column table val -> Expression table
+gte val (Column colName encoder) =
+    Expression (colName ++ " >= ?") [ encoder val ]
+
+
+lt : val -> Column table val -> Expression table
+lt val (Column colName encoder) =
+    Expression (colName ++ " < ?") [ encoder val ]
+
+
+lte : val -> Column table val -> Expression table
+lte val (Column colName encoder) =
+    Expression (colName ++ " <= ?") [ encoder val ]
+
+
+like : String -> Column table val -> Expression table
+like search (Column colName _) =
+    Expression (colName ++ " LIKE ?") [ Encode.string search ]
+
+
+inList : List val -> Column table val -> Expression table
+inList values (Column colName encoder) =
+    let
+        placeholders =
+            List.map (\_ -> "?") values |> String.join ", "
+    in
+    Expression (colName ++ " IN (" ++ placeholders ++ ")") (List.map encoder values)
+
+
+isNull : Column table val -> Expression table
+isNull (Column colName _) =
+    Expression (colName ++ " IS NULL") []
+
+
+isNotNull : Column table val -> Expression table
+isNotNull (Column colName _) =
+    Expression (colName ++ " IS NOT NULL") []
+
+
+and : Expression table -> Expression table -> Expression table
+and (Expression sql1 params1) (Expression sql2 params2) =
+    Expression ("(" ++ sql1 ++ " AND " ++ sql2 ++ ")") (params1 ++ params2)
+
+
+or : Expression table -> Expression table -> Expression table
+or (Expression sql1 params1) (Expression sql2 params2) =
+    Expression ("(" ++ sql1 ++ " OR " ++ sql2 ++ ")") (params1 ++ params2)
+
+
+selectAll : Table table -> Decoder a -> Query table a
+selectAll (Table tableName) dec =
+    Query
+        { tableName = tableName
+        , selection = []
+        , conditions = []
+        , limitVal = Nothing
+        , decoder = dec
+        }
+
+
+select : Table table -> List (AnyColumn table) -> Decoder a -> Query table a
+select (Table tableName) columns dec =
+    let
+        selects =
+            List.map (\(AnyColumn colName) -> colName) columns
+    in
+    Query
+        { tableName = tableName
+        , selection = selects
+        , conditions = []
+        , limitVal = Nothing
+        , decoder = dec
+        }
+
+
+where_ : Expression table -> Query table a -> Query table a
+where_ cond (Query q) =
+    Query { q | conditions = q.conditions ++ [ cond ] }
+
+
+limit : Int -> Query table a -> Query table a
+limit val (Query q) =
+    Query { q | limitVal = Just val }
+
+
+compileQuery : Query table a -> { sql : String, params : List Encode.Value, decoder : Decoder a }
+compileQuery (Query q) =
+    let
+        selectsStr =
+            if List.isEmpty q.selection then
+                "*"
+
+            else
+                String.join ", " q.selection
+
+        baseSql =
+            "SELECT " ++ selectsStr ++ " FROM " ++ q.tableName
+
+        ( whereSql, params ) =
+            if List.isEmpty q.conditions then
+                ( "", [] )
+
+            else
+                let
+                    sqls =
+                        List.map (\(Expression sql _) -> sql) q.conditions
+                            |> String.join " AND"
+                            -- Note: we join multi-where conditions with AND
+                            -- and wrap the expressions in parentheses if needed,
+                            -- but a simple join with AND works since operators have higher precedence.
+                    
+                    vals =
+                        List.map (\(Expression _ valsList) -> valsList) q.conditions
+                            |> List.concat
+                in
+                ( " WHERE " ++ sqls, vals )
+
+        limitSql =
+            case q.limitVal of
+                Just l ->
+                    " LIMIT " ++ String.fromInt l
+
+                Nothing ->
+                    ""
+    in
+    { sql = baseSql ++ whereSql ++ limitSql
+    , params = params
+    , decoder = q.decoder
+    }
+
+
+toLoader : Query table a -> Loader (List a)
+toLoader q =
+    let
+        c =
+            compileQuery q
+    in
+    Loader.query { sql = c.sql, params = c.params, decoder = c.decoder }
+
+
+toLoaderOne : Query table a -> Loader (Maybe a)
+toLoaderOne q =
+    let
+        c =
+            compileQuery q
+    in
+    Loader.queryOne { sql = c.sql, params = c.params, decoder = c.decoder }

package/elm-src/ElmSsr/Loader.elm

@@ -1,6 +1,6 @@
 module ElmSsr.Loader exposing
     ( Loader
-    , succeed, fail
+    , succeed, fail, redirect, requireUser
     , map, map2, andThen
     , fetchJson
     , cacheGet, cachePut
@@ -89,6 +89,7 @@ import Json.Encode as Encode
 type Loader a
     = Done a
     | Failed Int String
+    | Redirect String
     | Pending Effect (Decode.Value -> Loader a)
 
 
@@ -113,6 +114,27 @@ fail status message =
     Failed status message
 
 
+{-| Redirect the browser progressively to a same-origin or external URL. -}
+redirect : String -> Loader a
+redirect url =
+    Redirect url
+
+
+{-| Require a user session. If missing, redirect to the login path. -}
+requireUser : Decoder user -> String -> (user -> Loader a) -> Loader a
+requireUser userDecoder loginPath toLoader =
+    session userDecoder
+        |> andThen
+            (\maybeUser ->
+                case maybeUser of
+                    Just user ->
+                        toLoader user
+
+                    Nothing ->
+                        redirect loginPath
+            )
+
+
 {-| Transform the value a loader resolves to. -}
 map : (a -> b) -> Loader a -> Loader b
 map fn loader =
@@ -123,6 +145,9 @@ map fn loader =
         Failed status message ->
             Failed status message
 
+        Redirect url ->
+            Redirect url
+
         Pending effect continue ->
             Pending effect (\value -> map fn (continue value))
 
@@ -139,6 +164,9 @@ andThen fn loader =
         Failed status message ->
             Failed status message
 
+        Redirect url ->
+            Redirect url
+
         Pending effect continue ->
             Pending effect (\value -> andThen fn (continue value))
 
@@ -537,6 +565,7 @@ the effect result.
 type Step a
     = Resolved a
     | Errored Int String
+    | Moved String
     | Await Effect (Decode.Value -> Loader a)
 
 
@@ -550,6 +579,9 @@ step loader =
         Failed status message ->
             Errored status message
 
+        Redirect url ->
+            Moved url
+
         Pending effect continue ->
             Await effect continue