@junejs/server 0.0.7 → 0.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@junejs/server",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "description": "June host adapters + dev server. Host-coupled; depends on the pure @junejs/core contract layer.",
   "type": "module",
   "license": "MIT",
@@ -29,7 +29,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@junejs/core": "0.0.7",
+    "@junejs/core": "0.0.8",
     "marked": "^18.0.5",
     "rolldown": "^1.1.0"
   },

package/src/build.ts

@@ -341,15 +341,24 @@ ${chains.join("\n")}
     const pkg = existsSync(pkgPath)
       ? (JSON.parse(await Bun.file(pkgPath).text()) as { name?: string })
       : {};
+    const deployCfg = (await loadJuneConfig(appRoot)).deploy;
     await writeFile(
       join(outDir, "wrangler.jsonc"),
       JSON.stringify(
         {
-          name: (pkg.name ?? basename(appRoot)).replace(/[^a-z0-9-]/gi, "-").toLowerCase(),
+          name:
+            deployCfg?.name ??
+            (pkg.name ?? basename(appRoot)).replace(/[^a-z0-9-]/gi, "-").toLowerCase(),
           main: "./worker.js",
           compatibility_date: "2025-01-01",
           compatibility_flags: ["nodejs_compat"],
           ...(hasAssets ? { assets: { directory: "./assets" } } : {}),
+          // config deploy.domain → a Workers custom domain; without it the
+          // generated file regenerating on every build would silently drop a
+          // hand-attached domain.
+          ...(deployCfg?.domain
+            ? { routes: [{ pattern: deployCfg.domain, custom_domain: true }] }
+            : {}),
         },
         null,
         2,

package/src/db.ts

@@ -3,15 +3,28 @@
 // by the host, injected onto RouteContext as `ctx.db`. The framework depends on
 // the JuneDb contract; these adapters (and Juno on top) are swappable.
 
+import { mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+
 import type { DbFactory, JuneDb, RunResult } from "@junejs/core/resources";
 
 import { host } from "./host";
 
-// Local SQLite — the zero-config dev default (embedded file or :memory:). Built
-// on the demoted host.openDb primitive (the sync bun:/node: driver wrapped async).
+// Local SQLite — the zero-config dev default. A persistent FILE, not :memory:,
+// on purpose: `june dev` restarts the process on every save (the watch
+// supervisor), so an in-memory default would evaporate your dev data at each
+// edit. A file also makes the dev db inspectable with the sqlite3 every
+// machine already has (`sqlite3 .june/dev.sqlite`). Pass ":memory:" explicitly
+// for ephemerality.
 export function sqlite(opts: { path?: string } = {}): DbFactory {
-  const path = opts.path ?? ":memory:";
-  return { kind: "sqlite", open: () => host.openDb(path) };
+  const path = opts.path ?? ".june/dev.sqlite";
+  return {
+    kind: "sqlite",
+    open: () => {
+      if (path !== ":memory:") mkdirSync(dirname(path), { recursive: true });
+      return host.openDb(path);
+    },
+  };
 }
 
 // --- D1 (Cloudflare) — the third openDb impl (rebuild-plan Phase 5) ----------

package/src/pipeline.ts

@@ -95,6 +95,23 @@ function text(body: string, contentType: string, init?: ResponseInit) {
   return new Response(body, { ...init, headers });
 }
 
+// The default favicon: the site name's first character in a rounded square —
+// a plain SVG string, so it needs no fonts, no rasterizer, and works for CJK
+// names as readily as latin ones. Served at /favicon.svg AND /favicon.ico
+// (browsers respect the svg content-type), so no June app 404s its icon.
+function letterFavicon(siteName: string | undefined): Response {
+  const first = (siteName ?? "").trim().charAt(0) || "•";
+  const letter = first.toUpperCase().replace(/[<>&"']/g, "");
+  return text(
+    `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64">` +
+      `<rect width="64" height="64" rx="12" fill="#1d1d1f"/>` +
+      `<text x="32" y="32" dy=".36em" text-anchor="middle" font-family="ui-sans-serif, system-ui, sans-serif" font-size="34" font-weight="600" fill="#fbfbf8">${letter || "•"}</text>` +
+      `</svg>\n`,
+    "image/svg+xml",
+    { headers: { "cache-control": "public, max-age=86400" } },
+  );
+}
+
 export function createPipeline(cfg: PipelineConfig): Pipeline {
   const { docConfig, agent } = cfg;
   const NotFound = cfg.notFoundComponent ?? DefaultNotFound;
@@ -219,6 +236,15 @@ export function createPipeline(cfg: PipelineConfig): Pipeline {
         if (out) return out;
       }
 
+      // --- default favicon (after extra so an app can override it) ----------
+      if (
+        request.method === "GET" &&
+        !docConfig.site.icon &&
+        (url.pathname === "/favicon.svg" || url.pathname === "/favicon.ico")
+      ) {
+        return letterFavicon(docConfig.site.name);
+      }
+
       // --- routes ----------------------------------------------------------
       const { target, pathname, speculative } = negotiate(url, request);
       const resolved = await cfg.resolve(pathname);

package/src/router.ts

@@ -67,8 +67,12 @@ function isSpecialFile(file: string) {
 
 const isRouteGroup = (name: string) => /^\(.+\)$/.test(name);
 const isParamDir = (name: string) => /^\[([A-Za-z_][A-Za-z0-9_]*)\]$/.test(name);
+// [[slug]] / [[...slug]] — match like their required forms, and ALSO match the
+// segment being absent (the param is then simply missing from ctx.params).
+const isOptionalDir = (name: string) => /^\[\[([A-Za-z_][A-Za-z0-9_]*)\]\]$/.test(name);
+const isOptionalCatchAllDir = (name: string) => /^\[\[\.\.\.([A-Za-z_][A-Za-z0-9_]*)\]\]$/.test(name);
 const isCatchAllDir = (name: string) => /^\[\.\.\.([A-Za-z_][A-Za-z0-9_]*)\]$/.test(name);
-const paramName = (name: string) => name.replace(/^\[(\.\.\.)?|\]$/g, "");
+const paramName = (name: string) => name.replace(/^\[+(\.\.\.)?|\]+$/g, "");
 
 type DirEntry = { name: string; dir: boolean };
 
@@ -164,7 +168,16 @@ export async function matchRouteTree(
       if (hit) return hit;
     }
 
-    if (rest.length === 0) return null;
+    if (rest.length === 0) {
+      // Optional segments match ABSENCE too: descend without consuming and
+      // without setting the param.
+      for (const e of entries) {
+        if (!e.dir || !(isOptionalDir(e.name) || isOptionalCatchAllDir(e.name))) continue;
+        const hit = await descend(join(dir, e.name), [], params, segments);
+        if (hit) return hit;
+      }
+      return null;
+    }
     const [head, ...tail] = rest as [string, ...string[]];
 
     // 1) exact static dir
@@ -173,9 +186,9 @@ export async function matchRouteTree(
       const hit = await descend(join(dir, head), tail, params, segments);
       if (hit) return hit;
     }
-    // 2) [param] dirs
+    // 2) [param] and [[param]] dirs consume one segment
     for (const e of entries) {
-      if (!e.dir || !isParamDir(e.name)) continue;
+      if (!e.dir || !(isParamDir(e.name) || isOptionalDir(e.name))) continue;
       const hit = await descend(
         join(dir, e.name),
         tail,
@@ -184,9 +197,9 @@ export async function matchRouteTree(
       );
       if (hit) return hit;
     }
-    // 3) [...catchAll] dirs consume everything remaining
+    // 3) [...catchAll] and [[...catchAll]] dirs consume everything remaining
     for (const e of entries) {
-      if (!e.dir || !isCatchAllDir(e.name)) continue;
+      if (!e.dir || !(isCatchAllDir(e.name) || isOptionalCatchAllDir(e.name))) continue;
       const hit = await descend(
         join(dir, e.name),
         [],

package/src/worker.ts

@@ -41,26 +41,45 @@ export type WorkerManifest = {
 
 type Compiled = { regex: RegExp; names: string[]; def: BrandedRoute; pattern: string };
 
-// "/posts/[slug]" | "/docs/[...path]" → matcher
+// "/posts/[slug]" | "/docs/[...path]" | "/notes/[[tag]]" → matcher. Optional
+// segments ([[x]], [[...x]]) wrap slash + capture together so absence matches;
+// a pattern of ONLY optional segments must also match the bare "/".
 function compilePattern(pattern: string): { regex: RegExp; names: string[] } {
   const names: string[] = [];
-  const source = pattern
-    .split("/")
-    .map((seg) => {
-      const ca = seg.match(/^\[\.\.\.(\w+)\]$/);
-      if (ca) {
-        names.push(ca[1]!);
-        return "(.+)";
-      }
-      const p = seg.match(/^\[(\w+)\]$/);
-      if (p) {
-        names.push(p[1]!);
-        return "([^/]+)";
-      }
-      return seg.replace(/[.*+?^${}()|\\]/g, "\\$&");
-    })
-    .join("/");
-  return { regex: new RegExp(`^${source}$`), names };
+  let source = "";
+  let allOptional = true;
+  for (const seg of pattern.split("/").filter(Boolean)) {
+    const oca = seg.match(/^\[\[\.\.\.(\w+)\]\]$/);
+    if (oca) {
+      names.push(oca[1]!);
+      source += "(?:/(.+))?";
+      continue;
+    }
+    const ca = seg.match(/^\[\.\.\.(\w+)\]$/);
+    if (ca) {
+      names.push(ca[1]!);
+      source += "/(.+)";
+      allOptional = false;
+      continue;
+    }
+    const op = seg.match(/^\[\[(\w+)\]\]$/);
+    if (op) {
+      names.push(op[1]!);
+      source += "(?:/([^/]+))?";
+      continue;
+    }
+    const p = seg.match(/^\[(\w+)\]$/);
+    if (p) {
+      names.push(p[1]!);
+      source += "/([^/]+)";
+      allOptional = false;
+      continue;
+    }
+    source += "/" + seg.replace(/[.*+?^${}()|\\]/g, "\\$&");
+    allOptional = false;
+  }
+  if (source === "") return { regex: /^\/$/, names };
+  return { regex: new RegExp(allOptional ? `^(?:${source}|/)$` : `^${source}$`), names };
 }
 
 export function createWorker(manifest: WorkerManifest): { fetch(request: Request): Promise<Response> } {
@@ -91,7 +110,14 @@ export function createWorker(manifest: WorkerManifest): { fetch(request: Request
       for (const d of dynamic) {
         const m = pathname.match(d.regex);
         if (m) {
-          const params = Object.fromEntries(d.names.map((n, i) => [n, decodeURIComponent(m[i + 1]!)]));
+          // Optional segments leave their capture undefined — the param is
+          // then absent, matching the dev matcher's semantics.
+          const params = Object.fromEntries(
+            d.names.flatMap((n, i) => {
+              const v = m[i + 1];
+              return v === undefined ? [] : [[n, decodeURIComponent(v)]];
+            }),
+          );
           return { def: d.def, params, chain: chainFor(d.pattern) };
         }
       }