elm-ssr 1.0.5 → 1.0.6

package/README.md

@@ -48,12 +48,13 @@ Creates a new app under `<workspace>/<name>/` (or `<workspace>/<subdir>/<name>/`
 - `--db`: Configures SQLite database support and an initial migration.
 - `--auth <betterAuth|auth0>`: Scaffolds authentication views, cookies, and callback handlers.
 
-### `route <path> [--app <name>] [--api] [--ws] [--sse]`
-Scaffolds a new route or endpoint:
+### `route <path> [--app <name>] [--api] [--ws] [--sse] [--resource]`
+Scaffolds a new route or endpoint (uses `ElmSsr.Form` for modern full-stack examples):
 - `--app <app-name>`: Required if multiple apps are configured in the workspace.
 - `--api`: Scaffolds a JSON API page/action route instead of an HTML page.
 - `--ws` or `--websocket`: Scaffolds a TypeScript WebSocket handler in `src/Endpoints/<route>.ts`.
 - `--sse`: Scaffolds a TypeScript Server-Sent Events (SSE) stream handler in `src/Endpoints/<route>.ts`.
+- `--resource`: Generates a richer CRUD-style example with `Form` validation + Elmto hints.
 
 ### `query [--app <name>] [--dir <path>] [--output <path>]`
 Generates type-safe Elm database schema and query helpers directly from raw SQL files in the migrations directory.

package/bin/elm-ssr.mjs

@@ -3,7 +3,7 @@
 import { readFile, stat } from "node:fs/promises";
 import { watch } from "node:fs";
 import { dirname, resolve } from "node:path";
-import { createAppScaffold, createRouteScaffold } from "../lib/scaffold.mjs";
+import { createAppScaffold, createRouteScaffold, addAuthProvider, listAuthProviders, ensureScaffoldCodegen } from "../lib/scaffold.mjs";
 import { readWorkspaceConfig } from "../lib/workspace.mjs";
 import { build } from "../lib/build.mjs";
 import { migrate } from "../lib/migrate.mjs";
@@ -13,6 +13,12 @@ const defaultRootPath = process.cwd();
 const args = process.argv.slice(2);
 const command = args[0] ?? "help";
 
+// Ensure Elm-based scaffold generator is available (hybrid Elm/JS for better debuggability).
+// Also ensure on "build" so editing the Elm generator is reflected in dev/CI flows.
+if (["new", "init", "route", "build"].includes(command)) {
+  await ensureScaffoldCodegen();
+}
+
 const ownPkg = JSON.parse(
   await readFile(new URL("../package.json", import.meta.url), "utf8")
 );
@@ -45,7 +51,7 @@ const userRoot = findFlagValue("--root");
 let rootPath;
 if (userRoot) {
   rootPath = resolve(userRoot);
-} else if (["new", "init", "migrate", "help"].includes(command)) {
+} else if (["new", "init", "migrate", "help", "version", "--version", "-v"].includes(command)) {
   rootPath = defaultRootPath;
 } else {
   rootPath = resolve(await findWorkspaceRoot(defaultRootPath));
@@ -91,6 +97,8 @@ const printHelp = () => {
   info          Print current workspace package and configured app names
   migrate ...   Apply / revert / inspect SQL migrations (see: elm-ssr migrate --help)
   version       Print the elm-ssr version
+  auth add <provider> [--app <name>]  Add an auth provider to an app (betterAuth | auth0)
+  auth list [--app <name>]            List configured auth providers
 `);
 };
 
@@ -276,7 +284,8 @@ switch (command) {
     requireConfig();
     const routePath = args[1];
     if (!routePath) {
-      console.error("Usage: elm-ssr route <path> [--app <app-name>] [--api] [--ws] [--sse]");
+      console.error("Usage: elm-ssr route <path> [--app <app-name>] [--api] [--ws] [--sse] [--resource]");
+      console.error("  --resource   Scaffold a richer CRUD-ish page using Form (recommended for full-stack examples)");
       process.exit(1);
     }
     
@@ -301,8 +310,9 @@ switch (command) {
     const isApi = args.includes("--api");
     const isWs = args.includes("--ws") || args.includes("--websocket");
     const isSse = args.includes("--sse");
+    const isResource = args.includes("--resource");
 
-    const result = await createRouteScaffold(rootPath, appConfig, routePath, { isApi, isWs, isSse });
+    const result = await createRouteScaffold(rootPath, appConfig, routePath, { isApi, isWs, isSse, isResource });
     console.log(`Scaffolded ${result.type} route at ${result.path}`);
     if (result.instructions) {
       console.log("\nInstructions to wire it up:\n" + result.instructions);
@@ -348,6 +358,80 @@ switch (command) {
     break;
   }
 
+  case "auth": {
+    const subcommand = args[1];
+
+    if (subcommand === "list") {
+      requireConfig();
+      const appName = findFlagValue("--app");
+      const apps = appName
+        ? config.apps.filter(a => a.name === appName)
+        : config.apps;
+      if (apps.length === 0) {
+        console.error(appName
+          ? `Error: App "${appName}" not found in elm-ssr.config.json`
+          : "Error: No apps found in elm-ssr.config.json");
+        process.exit(1);
+      }
+      for (const app of apps) {
+        const providers = await listAuthProviders(rootPath, app);
+        if (providers.length === 0) {
+          console.log(`${app.name}: no auth providers configured`);
+        } else {
+          console.log(`${app.name}: ${providers.join(", ")}`);
+        }
+      }
+      break;
+    }
+
+    if (subcommand === "add") {
+      requireConfig();
+      const providerArg = args[2];
+      if (!providerArg) {
+        console.error("Usage: elm-ssr auth add <provider> [--app <name>]");
+        console.error("  Providers: betterAuth, auth0");
+        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. Specify one with --app <name>");
+        console.error("Available:", config.apps.map(a => a.name).join(", "));
+        process.exit(1);
+      }
+      try {
+        const result = await addAuthProvider(rootPath, appConfig, providerArg);
+        console.log(`Added ${result.name} to ${appConfig.name}`);
+        console.log(`\nNext steps:`);
+        if (result.provider === "better-auth") {
+          console.log(`  1. Run: bun install`);
+          console.log(`  2. Run: elm-ssr migrate`);
+          console.log(`  3. Set BETTER_AUTH_SECRET in ${appConfig.root}/.dev.vars`);
+        } else {
+          console.log(`  1. Set AUTH0_DOMAIN, AUTH0_CLIENT_ID, AUTH0_CLIENT_SECRET in ${appConfig.root}/.dev.vars`);
+        }
+        console.log(`  4. Run: bun run build`);
+      } catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+      }
+      break;
+    }
+
+    console.error("Usage: elm-ssr auth <add|list> [...]");
+    console.error("  elm-ssr auth add betterAuth --app my-app");
+    console.error("  elm-ssr auth list --app my-app");
+    process.exit(1);
+  }
+
   case "migrate":
     await migrate(args.slice(1));
     break;

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

@@ -13,6 +13,10 @@ module ElmSsr.Db.Dsl exposing
     , compileQuery
     )
 
+{-| LEGACY. Elmto is canonical (ElmSsr.Db.Elmto + Repo + Query).
+Generator no longer produces Dsl modules. This is for porting only.
+-}
+
 import Json.Decode as Decode exposing (Decoder)
 import Json.Encode as Encode
 import ElmSsr.Loader as Loader exposing (Loader)

package/elm-src/ElmSsr/Document/Events.elm

@@ -1,6 +1,11 @@
 module ElmSsr.Document.Events exposing (EventRef, decodeEventRef, encodeEventRef, findMessage)
 
-{-| Browser events are bridged without serializing `Msg`. An event handler is
+{-| LEGACY / vestigial.
+
+Only used to support very old page event wiring if any; islands should use
+stock `elm/html` `Html.Events` + the client runtime.
+
+Browser events are bridged without serializing `Msg`. An event handler is
 rendered as an `EventRef` (a DOM path + event name); when the browser reports an
 event, the runtime looks the message back up against the current view with
 [`findMessage`](#findMessage).

package/elm-src/ElmSsr/Form.elm

@@ -0,0 +1,470 @@
+module ElmSsr.Form exposing
+    ( Decoder, Error, FieldDecoder
+    , required, optional, optionalWithDefault
+    , string, int, float, bool
+    , validate, custom
+    , succeed, fail, map, map2, map3, map4, map5, map6, map7, map8, andThen
+    , decode
+    , email, nonEmpty, minInt, maxInt, minFloat, maxFloat, minLength, maxLength
+    , errorFor, hasError, errorsFor
+    )
+
+{-| Type-safe form and request validation.
+
+Decoders are pure and can be used on the server (via Request data) and in islands
+(via plain key/value pairs from model state). Errors accumulate.
+
+Use on the server with `decode` + `Request.formData` (or the thin wrappers in
+`ElmSsr.Request.Decode`).
+
+# Core types
+@docs Decoder, Error
+
+# Building decoders
+@docs required, optional, optionalWithDefault
+@docs string, int, float, bool
+@docs validate, custom
+@docs succeed, fail, map, map2, map3, map4, map5, map6, map7, map8, andThen
+
+# Running
+@docs decode
+
+# Validators
+@docs email, nonEmpty, minInt, maxInt, minFloat, maxFloat, minLength, maxLength
+
+# Error helpers (usable on server and client)
+@docs errorFor, hasError, errorsFor
+-}
+
+import Json.Decode as JD
+import Json.Encode as JE
+
+
+type alias Error =
+    { field : String
+    , message : String
+    }
+
+
+type Decoder a
+    = Decoder (List ( String, String ) -> Result (List Error) a)
+
+
+type FieldDecoder a
+    = FieldDecoder (Maybe String -> Result String a)
+
+
+decode : Decoder a -> List ( String, String ) -> Result (List Error) a
+decode (Decoder dec) input =
+    dec input
+
+
+decodeField : FieldDecoder a -> Maybe String -> Result Error a
+decodeField (FieldDecoder fd) raw =
+    case fd raw of
+        Ok v ->
+            Ok v
+
+        Err msg ->
+            Err { field = "", message = msg }
+
+
+required : String -> FieldDecoder b -> Decoder (b -> a) -> Decoder a
+required name (FieldDecoder fieldDec) (Decoder decFn) =
+    Decoder (\input ->
+        let
+            rawValue =
+                lookup name input
+
+            resFn =
+                decFn input
+
+            resVal =
+                case fieldDec rawValue of
+                    Ok val ->
+                        Ok val
+
+                    Err msg ->
+                        Err [ { field = name, message = msg } ]
+        in
+        combine resFn resVal
+    )
+
+
+optional : String -> FieldDecoder b -> Decoder (Maybe b -> a) -> Decoder a
+optional name (FieldDecoder fieldDec) (Decoder decFn) =
+    Decoder (\input ->
+        let
+            rawValue =
+                lookup name input
+
+            resFn =
+                decFn input
+
+            resVal =
+                case rawValue of
+                    Nothing ->
+                        Ok Nothing
+
+                    Just "" ->
+                        Ok Nothing
+
+                    Just val ->
+                        case fieldDec (Just val) of
+                            Ok decoded ->
+                                Ok (Just decoded)
+
+                            Err msg ->
+                                Err [ { field = name, message = msg } ]
+        in
+        combine resFn resVal
+    )
+
+
+optionalWithDefault : String -> b -> FieldDecoder b -> Decoder (b -> a) -> Decoder a
+optionalWithDefault name defaultVal (FieldDecoder fieldDec) (Decoder decFn) =
+    Decoder (\input ->
+        let
+            rawValue =
+                lookup name input
+
+            resFn =
+                decFn input
+
+            resVal =
+                case rawValue of
+                    Nothing ->
+                        Ok defaultVal
+
+                    Just "" ->
+                        Ok defaultVal
+
+                    Just val ->
+                        case fieldDec (Just val) of
+                            Ok decoded ->
+                                Ok decoded
+
+                            Err msg ->
+                                Err [ { field = name, message = msg } ]
+        in
+        combine resFn resVal
+    )
+
+
+string : FieldDecoder String
+string =
+    FieldDecoder (\rawValue ->
+        case rawValue of
+            Just val ->
+                Ok val
+
+            Nothing ->
+                Err "Field is required"
+    )
+
+
+int : FieldDecoder Int
+int =
+    FieldDecoder (\rawValue ->
+        case rawValue of
+            Just val ->
+                case String.toInt val of
+                    Just num ->
+                        Ok num
+
+                    Nothing ->
+                        Err "Must be a valid integer"
+
+            Nothing ->
+                Err "Field is required"
+    )
+
+
+float : FieldDecoder Float
+float =
+    FieldDecoder (\rawValue ->
+        case rawValue of
+            Just val ->
+                case String.toFloat val of
+                    Just num ->
+                        Ok num
+
+                    Nothing ->
+                        Err "Must be a valid number"
+
+            Nothing ->
+                Err "Field is required"
+    )
+
+
+bool : FieldDecoder Bool
+bool =
+    FieldDecoder (\rawValue ->
+        case rawValue of
+            Just "true" ->
+                Ok True
+
+            Just "false" ->
+                Ok False
+
+            Just "on" ->
+                Ok True
+
+            Just "" ->
+                Ok False
+
+            Just _ ->
+                Ok False
+
+            Nothing ->
+                Ok False
+    )
+
+
+validate : (a -> Result String a) -> FieldDecoder a -> FieldDecoder a
+validate validator (FieldDecoder fieldDec) =
+    FieldDecoder (\rawValue ->
+        fieldDec rawValue
+            |> Result.andThen validator
+    )
+
+
+custom : (a -> Result String b) -> FieldDecoder a -> FieldDecoder b
+custom f (FieldDecoder fieldDec) =
+    FieldDecoder (\rawValue ->
+        fieldDec rawValue
+            |> Result.andThen f
+    )
+
+
+succeed : a -> Decoder a
+succeed val =
+    Decoder (\_ -> Ok val)
+
+
+fail : String -> String -> Decoder a
+fail fieldName msg =
+    Decoder (\_ -> Err [ { field = fieldName, message = msg } ])
+
+
+map : (a -> b) -> Decoder a -> Decoder b
+map f (Decoder dec) =
+    Decoder (\input -> Result.map f (dec input))
+
+
+apply : Decoder a -> Decoder (a -> b) -> Decoder b
+apply (Decoder decVal) (Decoder decFn) =
+    Decoder (\input ->
+        combine (decFn input) (decVal input)
+    )
+
+
+map2 : (a -> b -> c) -> Decoder a -> Decoder b -> Decoder c
+map2 f decA decB =
+    succeed f
+        |> apply decA
+        |> apply decB
+
+
+map3 : (a -> b -> c -> d) -> Decoder a -> Decoder b -> Decoder c -> Decoder d
+map3 f decA decB decC =
+    succeed f
+        |> apply decA
+        |> apply decB
+        |> apply decC
+
+
+map4 : (a -> b -> c -> d -> e) -> Decoder a -> Decoder b -> Decoder c -> Decoder d -> Decoder e
+map4 f decA decB decC decD =
+    succeed f
+        |> apply decA
+        |> apply decB
+        |> apply decC
+        |> apply decD
+
+
+map5 : (a -> b -> c -> d -> e -> f) -> Decoder a -> Decoder b -> Decoder c -> Decoder d -> Decoder e -> Decoder f
+map5 f decA decB decC decD decE =
+    succeed f
+        |> apply decA
+        |> apply decB
+        |> apply decC
+        |> apply decD
+        |> apply decE
+
+
+map6 : (a -> b -> c -> d -> e -> f -> g) -> Decoder a -> Decoder b -> Decoder c -> Decoder d -> Decoder e -> Decoder f -> Decoder g
+map6 f decA decB decC decD decE decF =
+    succeed f
+        |> apply decA
+        |> apply decB
+        |> apply decC
+        |> apply decD
+        |> apply decE
+        |> apply decF
+
+
+map7 : (a -> b -> c -> d -> e -> f -> g -> h) -> Decoder a -> Decoder b -> Decoder c -> Decoder d -> Decoder e -> Decoder f -> Decoder g -> Decoder h
+map7 f decA decB decC decD decE decF decG =
+    succeed f
+        |> apply decA
+        |> apply decB
+        |> apply decC
+        |> apply decD
+        |> apply decE
+        |> apply decF
+        |> apply decG
+
+
+map8 : (a -> b -> c -> d -> e -> f -> g -> h -> i) -> Decoder a -> Decoder b -> Decoder c -> Decoder d -> Decoder e -> Decoder f -> Decoder g -> Decoder h -> Decoder i
+map8 f decA decB decC decD decE decF decG decH =
+    succeed f
+        |> apply decA
+        |> apply decB
+        |> apply decC
+        |> apply decD
+        |> apply decE
+        |> apply decF
+        |> apply decG
+        |> apply decH
+
+
+andThen : (a -> Decoder b) -> Decoder a -> Decoder b
+andThen f (Decoder decA) =
+    Decoder (\input ->
+        case decA input of
+            Ok a ->
+                let
+                    (Decoder decB) =
+                        f a
+                in
+                decB input
+
+            Err errs ->
+                Err errs
+    )
+
+
+email : String -> Result String String
+email val =
+    let
+        parts =
+            String.split "@" val
+    in
+    case parts of
+        [ _, domain ] ->
+            if String.contains "." domain then
+                Ok val
+
+            else
+                Err "Invalid email address"
+
+        _ ->
+            Err "Invalid email address"
+
+
+nonEmpty : String -> Result String String
+nonEmpty val =
+    if String.isEmpty (String.trim val) then
+        Err "Cannot be empty"
+
+    else
+        Ok val
+
+
+minInt : Int -> Int -> Result String Int
+minInt min val =
+    if val >= min then
+        Ok val
+
+    else
+        Err ("Must be at least " ++ String.fromInt min)
+
+
+maxInt : Int -> Int -> Result String Int
+maxInt max val =
+    if val <= max then
+        Ok val
+
+    else
+        Err ("Must be at most " ++ String.fromInt max)
+
+
+minFloat : Float -> Float -> Result String Float
+minFloat min val =
+    if val >= min then
+        Ok val
+
+    else
+        Err ("Must be at least " ++ String.fromFloat min)
+
+
+maxFloat : Float -> Float -> Result String Float
+maxFloat max val =
+    if val <= max then
+        Ok val
+
+    else
+        Err ("Must be at most " ++ String.fromFloat max)
+
+
+minLength : Int -> String -> Result String String
+minLength len val =
+    if String.length val >= len then
+        Ok val
+
+    else
+        Err ("Must be at least " ++ String.fromInt len ++ " characters")
+
+
+maxLength : Int -> String -> Result String String
+maxLength len val =
+    if String.length val <= len then
+        Ok val
+
+    else
+        Err ("Must be at most " ++ String.fromInt len ++ " characters")
+
+
+errorFor : String -> List Error -> Maybe String
+errorFor field errors =
+    errors
+        |> List.filter (\e -> e.field == field)
+        |> List.head
+        |> Maybe.map .message
+
+
+hasError : String -> List Error -> Bool
+hasError field errors =
+    List.any (\e -> e.field == field) errors
+
+
+errorsFor : String -> List Error -> List String
+errorsFor field errors =
+    errors
+        |> List.filter (\e -> e.field == field)
+        |> List.map .message
+
+
+lookup : String -> List ( String, String ) -> Maybe String
+lookup key pairs =
+    pairs
+        |> List.filter (\( name, _ ) -> name == key)
+        |> List.head
+        |> Maybe.map Tuple.second
+
+
+combine : Result (List Error) (a -> b) -> Result (List Error) a -> Result (List Error) b
+combine resFn resVal =
+    case ( resFn, resVal ) of
+        ( Ok fn, Ok val ) ->
+            Ok (fn val)
+
+        ( Err errsFn, Err errsVal ) ->
+            Err (errsFn ++ errsVal)
+
+        ( Err errs, Ok _ ) ->
+            Err errs
+
+        ( Ok _, Err errs ) ->
+            Err errs

package/elm-src/ElmSsr/Html/Events.elm

@@ -5,6 +5,10 @@ module ElmSsr.Html.Events exposing
     , onBlur, onFocus
     )
 
+{-| LEGACY / vestigial. Pages are static SSR; events belong in islands using stock elm/html Html.Events.
+Kept only if Document.Events still references for legacy findMessage.
+-}
+
 {-| Event handlers. Mirrors `elm/html`'s `Html.Events`.
 
 Handlers are bridged by DOM path and event name, not by serializing `Msg`, so