@inglorious/ssx 0.1.3 → 0.2.0

package/README.md

@@ -721,11 +721,11 @@ Each handler receives three arguments:
   - `getTypes()` - type definitions (for middleware)
   - `getType(typeName)` - type definition (for overriding)
 
-### Built-in Lifecycle Events
+### Built-in Events
 
-- **`create(entity, id)`** - triggered when entity added via `add` event
-- **`destroy(entity, id)`** - triggered when entity removed via `remove` event
-- **`morph(entity, newType)`** - triggered when entity type changes
+- **`create(entity)`** - triggered when entity added via `add` event, visible only to that entity
+- **`destroy(entity)`** - triggered when entity removed via `remove` event, visible only to that entity
+- **`morph(typeName, newType)`** - used to change the behavior of a type on the fly
 
 ### Notify vs Dispatch
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inglorious/ssx",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "description": "Server-Side-X. Xecution? Xperience? Who knows.",
   "author": "IceOnFire <antony.mistretta@gmail.com> (https://ingloriouscoderz.it)",
   "license": "MIT",
@@ -39,8 +39,9 @@
     "access": "public"
   },
   "dependencies": {
+    "glob": "^13.0.0",
     "happy-dom": "^20.0.11",
-    "@inglorious/web": "2.6.0"
+    "@inglorious/web": "2.6.1"
   },
   "devDependencies": {
     "prettier": "^3.6.2",

package/src/__fixtures__/pages/about.js

@@ -0,0 +1,7 @@
+import { html } from "@inglorious/web"
+
+export const about = {
+  render() {
+    return html`<h1>About</h1>`
+  },
+}

package/src/__fixtures__/pages/api/[...path].js

@@ -0,0 +1,7 @@
+import { html } from "@inglorious/web"
+
+export const api = {
+  render() {
+    return html`<h1>API</h1>`
+  },
+}

package/src/__fixtures__/pages/blog/[slug].js

@@ -0,0 +1,7 @@
+import { html } from "@inglorious/web"
+
+export const blog = {
+  render() {
+    return html`<h1>Blog</h1>`
+  },
+}

package/src/__fixtures__/pages/index.js

@@ -0,0 +1,7 @@
+import { html } from "@inglorious/web"
+
+export const index = {
+  render() {
+    return html`<h1>Index</h1>`
+  },
+}

package/src/__fixtures__/pages/posts/[id].js

@@ -0,0 +1,11 @@
+import { html } from "@inglorious/web"
+
+export const posts = {
+  render() {
+    return html`<h1>Posts</h1>`
+  },
+}
+
+export async function getStaticPaths() {
+  return [{ path: "/posts/1", params: { id: "1" } }, "/posts/2"]
+}

package/src/build.js

@@ -0,0 +1,13 @@
+// import { renderPage } from "./render.js"
+// import { getPages } from "./router.js"
+
+export async function build() {
+  // const pages = await getPages()
+  // for (const page of pages) {
+  // const module = await import(page.filePath)
+  // const { html, storeConfig, renderFn } = await renderPage(module, page)
+  // TODO: implement this
+  // Inject client script and write to dist/
+  // await writePageToDisk(page.path, html, { storeConfig, renderFn })
+  // }
+}

package/src/render.js

@@ -0,0 +1,17 @@
+import { createStore } from "@inglorious/web"
+
+import { toHTML } from "./html"
+
+export async function renderPage(pageModule, context) {
+  const data = (await pageModule.getData?.(context)) ?? {}
+  const storeConfig = pageModule.getStore(data)
+  const store = createStore(storeConfig)
+
+  const html = toHTML(pageModule.render, store)
+
+  return {
+    html,
+    storeConfig,
+    renderFn: pageModule.render,
+  }
+}

package/src/router.js

@@ -0,0 +1,225 @@
+import path from "node:path"
+
+import { glob } from "glob"
+
+const NEXT_MATCH = 1
+
+const STATIC_SEGMENT_WEIGHT = 3
+const CATCH_ALL_ROUTE_WEIGHT = -10
+const SCORE_MULTIPLIER = 0.1
+
+/**
+ * Get all static paths for SSG build.
+ * This calls getStaticPaths() on dynamic route pages.
+ */
+export async function getPages(pagesDir = "pages") {
+  const routes = await getRoutes(pagesDir)
+  const pages = []
+
+  for (const route of routes) {
+    if (isDynamic(route.pattern)) {
+      // Dynamic route - call getStaticPaths if it exists
+      try {
+        const module = await import(path.resolve(route.filePath))
+
+        if (typeof module.getStaticPaths === "function") {
+          const paths = await module.getStaticPaths()
+
+          for (const pathOrObject of paths) {
+            const urlPath =
+              typeof pathOrObject === "string"
+                ? pathOrObject
+                : pathOrObject.path
+
+            const params = extractParams(route, urlPath)
+
+            pages.push({
+              path: urlPath,
+              filePath: route.filePath,
+              params,
+            })
+          }
+        } else {
+          console.warn(
+            `Dynamic route ${route.filePath} has no getStaticPaths export. ` +
+              `It will be skipped during SSG.`,
+          )
+        }
+      } catch (error) {
+        console.error(`Error loading ${route.filePath}:`, error)
+      }
+    } else {
+      // Static route - add directly
+      pages.push({
+        path: route.pattern === "" ? "/" : route.pattern,
+        filePath: route.filePath,
+        params: {},
+      })
+    }
+  }
+
+  return pages
+}
+
+/**
+ * Resolve a URL to a page file and extract params.
+ * Used by dev server for on-demand rendering.
+ */
+export async function resolvePage(url, pagesDir = "pages") {
+  const routes = await getRoutes(pagesDir)
+
+  // Normalize URL (remove query string and hash)
+  const [fullPath] = url.split("?")
+  const [normalizedUrl] = fullPath.split("#")
+
+  for (const route of routes) {
+    const match = route.regex.exec(normalizedUrl)
+
+    if (match) {
+      const params = {}
+      route.params.forEach((param, i) => {
+        params[param] = match[i + NEXT_MATCH]
+      })
+
+      return {
+        filePath: route.filePath,
+        params,
+      }
+    }
+  }
+
+  return null
+}
+
+/**
+ * Discovers all pages in the pages directory.
+ * Returns an array of route objects with pattern matching info.
+ */
+export async function getRoutes(pagesDir = "pages") {
+  // Find all .js and .ts files in pages directory
+  const files = await glob("**/*.{js,ts}", {
+    cwd: pagesDir,
+    ignore: ["**/_*.{js,ts}", "**/*.test.{js,ts}", "**/*.spec.{js,ts}"],
+  })
+
+  const routes = files.map((file) => {
+    const filePath = path.join(pagesDir, file)
+    const pattern = filePathToPattern(file)
+    const { regex, params } = patternToRegex(pattern)
+
+    return {
+      pattern,
+      filePath,
+      regex,
+      params,
+    }
+  })
+
+  // Sort routes by specificity (most specific first)
+  routes.sort((a, b) => {
+    const aScore = routeSpecificity(a.pattern)
+    const bScore = routeSpecificity(b.pattern)
+    return bScore - aScore
+  })
+
+  return routes
+}
+
+/**
+ * Convert a file path to a route pattern.
+ * pages/index.js -> /
+ * pages/about.js -> /about
+ * pages/blog/[slug].js -> /blog/:slug
+ * pages/api/[...path].js -> /api/*
+ */
+function filePathToPattern(file) {
+  let pattern = file
+    .replace(/\\/g, "/")
+    .replace(/\.(js|ts)$/, "") // Remove extension
+    .replace(/\/index$/, "") // index becomes root of directory
+    .replace(/^index$/, "") // Handle root index
+    .replace(/\[\.\.\.(\w+)\]/g, "*") // [...path] becomes *
+    .replace(/\[(\w+)\]/g, ":$1") // [id] becomes :id
+
+  // Normalize to start with /
+  return "/" + pattern.replace(/^\//, "")
+}
+
+/**
+ * Convert a route pattern to a regex and extract parameter names.
+ */
+function patternToRegex(pattern) {
+  const params = []
+
+  // Replace :param with capture groups
+  let regexStr = pattern.replace(/:(\w+)/g, (_, param) => {
+    params.push(param)
+    return "([^/]+)"
+  })
+
+  // Replace * with greedy capture
+  regexStr = regexStr.replace(/\*/g, () => {
+    params.push("path")
+    return "(.*)"
+  })
+
+  // Exact match
+  regexStr = "^" + regexStr + "$"
+
+  return {
+    regex: new RegExp(regexStr),
+    params,
+  }
+}
+
+/**
+ * Calculate route specificity for sorting.
+ * Higher score = more specific = should match first.
+ */
+function routeSpecificity(pattern) {
+  let score = 0
+
+  // Static segments add 3 points each
+  const segments = pattern.split("/").filter(Boolean)
+  segments.forEach((segment) => {
+    if (!segment.startsWith(":") && segment !== "*") {
+      score += STATIC_SEGMENT_WEIGHT
+    }
+  })
+
+  // Dynamic segments add 1 point
+  const dynamicCount = (pattern.match(/:/g) || []).length
+  score += dynamicCount
+
+  // Catch-all routes have lowest priority (subtract points)
+  if (pattern.includes("*")) {
+    score += CATCH_ALL_ROUTE_WEIGHT
+  }
+
+  // Longer paths are more specific
+  score += segments.length * SCORE_MULTIPLIER
+
+  return score
+}
+
+/**
+ * Check if a pattern is dynamic (contains params or wildcards).
+ */
+function isDynamic(pattern) {
+  return pattern.includes(":") || pattern.includes("*")
+}
+
+/**
+ * Extract params from a URL based on a route.
+ */
+function extractParams(route, url) {
+  const match = route.regex.exec(url)
+  if (!match) return {}
+
+  const params = {}
+  route.params.forEach((param, i) => {
+    params[param] = match[i + NEXT_MATCH]
+  })
+
+  return params
+}

package/src/router.test.js

@@ -0,0 +1,117 @@
+import path from "node:path"
+
+import { afterEach, describe, expect, it, vi } from "vitest"
+
+import { getPages, getRoutes, resolvePage } from "./router.js"
+
+const FIXTURES_DIR = path.join(__dirname, "__fixtures__", "pages")
+
+describe("router", () => {
+  afterEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  describe("getRoutes", () => {
+    it("should discover and sort routes correctly", async () => {
+      const routes = await getRoutes(FIXTURES_DIR)
+
+      // Expected order based on specificity:
+      // 1. /posts/:id (static 'posts' + dynamic 'id') -> score ~4.2
+      // 2. /blog/:slug (static 'blog' + dynamic 'slug') -> score ~4.2
+      // 3. /about (static 'about') -> score ~3.1
+      // 4. / (root) -> score 0
+      // 5. /api/* (catch-all) -> score negative
+
+      const patterns = routes.map((r) => r.pattern)
+
+      expect(patterns).toContain("/posts/:id")
+      expect(patterns).toContain("/blog/:slug")
+      expect(patterns).toContain("/about")
+      expect(patterns).toContain("/")
+      expect(patterns).toContain("/api/*")
+
+      // Check specific ordering constraints
+      // Specific routes before catch-all
+      expect(patterns.indexOf("/about")).toBeLessThan(
+        patterns.indexOf("/api/*"),
+      )
+      // Root usually comes after specific paths but before catch-all if it was a catch-all root,
+      // but here / is static.
+      // Let's just check that we found them.
+      expect(routes).toHaveLength(5)
+    })
+  })
+
+  describe("resolvePage", () => {
+    it("should resolve root page", async () => {
+      const page = await resolvePage("/", FIXTURES_DIR)
+      expect(page).not.toBeNull()
+      expect(page.filePath).toContain("index.js")
+      expect(page.params).toEqual({})
+    })
+
+    it("should resolve static page", async () => {
+      const page = await resolvePage("/about", FIXTURES_DIR)
+      expect(page).not.toBeNull()
+      expect(page.filePath).toContain("about.js")
+      expect(page.params).toEqual({})
+    })
+
+    it("should resolve dynamic page with params", async () => {
+      const page = await resolvePage("/blog/hello-world", FIXTURES_DIR)
+      expect(page).not.toBeNull()
+      expect(page.filePath).toContain("blog")
+      expect(page.params).toEqual({ slug: "hello-world" })
+    })
+
+    it("should resolve catch-all page", async () => {
+      const page = await resolvePage("/api/v1/users", FIXTURES_DIR)
+      expect(page).not.toBeNull()
+      expect(page.filePath).toContain("api")
+      expect(page.params).toEqual({ path: "v1/users" })
+    })
+
+    it("should return null for non-matching url", async () => {
+      // Since we have a catch-all /api/*, /api/foo matches.
+      // But /foo doesn't match anything except maybe if we had a root catch-all.
+      // We don't have a root catch-all, just /api/*.
+      // Wait, /blog/:slug matches /blog/foo.
+      // /posts/:id matches /posts/1.
+      // /about matches /about.
+      // / matches /.
+      // So /foo should return null.
+      const page = await resolvePage("/foo", FIXTURES_DIR)
+      expect(page).toBeNull()
+    })
+  })
+
+  describe("getPages", () => {
+    it("should generate static paths for all pages", async () => {
+      const consoleSpy = vi.spyOn(console, "warn").mockImplementation(() => {})
+      const pages = await getPages(FIXTURES_DIR)
+
+      // Static routes
+      expect(pages).toContainEqual(
+        expect.objectContaining({ path: "/", params: {} }),
+      )
+      expect(pages).toContainEqual(
+        expect.objectContaining({ path: "/about", params: {} }),
+      )
+
+      // Dynamic routes with getStaticPaths
+      expect(pages).toContainEqual(
+        expect.objectContaining({ path: "/posts/1", params: { id: "1" } }),
+      )
+      expect(pages).toContainEqual(
+        expect.objectContaining({ path: "/posts/2", params: { id: "2" } }),
+      )
+
+      // Dynamic route without getStaticPaths should be skipped (and warn)
+      const blogPage = pages.find((p) => p.path.includes("/blog/"))
+      expect(blogPage).toBeUndefined()
+
+      expect(consoleSpy).toHaveBeenCalled()
+      expect(consoleSpy.mock.calls[1][0]).toContain("has no getStaticPaths")
+    })
+  })
+})