@apex-stack/core 0.1.2 → 0.1.4

package/dist/{chunk-GC3WNE6M.js → chunk-IEXQ7E5C.js}

@@ -82,6 +82,18 @@ function sanitizeName(name) {
 function entryFor(pattern, method, mcpName, route) {
   return { pattern, segments: toSegments(pattern), method, mcpName, route };
 }
+function expandApiModule(name, def) {
+  if (!def) return [];
+  if (isApexResource(def)) {
+    return def.routes.map(
+      (r) => entryFor(`/api/${def.name}${r.pathSuffix}`, r.route.method, r.mcpName, r.route)
+    );
+  }
+  if (typeof def.handler === "function") {
+    return [entryFor(`/api/${name}`, def.method, sanitizeName(name), def)];
+  }
+  return [];
+}
 async function loadApiRoutes(root, loadModule) {
   const dir = join(root, "server", "api");
   if (!existsSync(dir)) return [];
@@ -89,14 +101,7 @@ async function loadApiRoutes(root, loadModule) {
   for (const file of readdirSync(dir).filter((f) => /\.(ts|js|mjs)$/.test(f))) {
     const name = file.replace(/\.(ts|js|mjs)$/, "");
     const def = (await loadModule(`/server/api/${file}`)).default;
-    if (!def) continue;
-    if (isApexResource(def)) {
-      for (const r of def.routes) {
-        entries.push(entryFor(`/api/${def.name}${r.pathSuffix}`, r.route.method, r.mcpName, r.route));
-      }
-    } else if (typeof def.handler === "function") {
-      entries.push(entryFor(`/api/${name}`, def.method, sanitizeName(name), def));
-    }
+    entries.push(...expandApiModule(name, def));
   }
   return entries;
 }
@@ -340,11 +345,9 @@ async function startDevServer(options) {
   });
   const app = createApp();
   app.use(fromNodeMiddleware(vite.middlewares));
-  const apiEntries = await loadApiRoutes(options.root, (id) => vite.ssrLoadModule(id));
-  if (apiEntries.length) app.use("/api", createApiHandler(apiEntries));
-  if (hasMcpRoutes(apiEntries)) {
-    app.use("/mcp", createMcpHandler(apiEntries));
-  }
+  const loadEntries = () => loadApiRoutes(options.root, (id) => vite.ssrLoadModule(id));
+  app.use("/api", defineEventHandler3((event) => loadEntries().then((e) => createApiHandler(e)(event))));
+  app.use("/mcp", defineEventHandler3((event) => loadEntries().then((e) => createMcpHandler(e)(event))));
   app.use(
     defineEventHandler3(async (event) => {
       const url = event.path || "/";
@@ -410,9 +413,14 @@ function notFoundPage(url, routes) {
 
 export {
   isApexResource,
+  expandApiModule,
+  createApiHandler,
+  hasMcpRoutes,
+  createMcpHandler,
   loadComponents,
   renderIslandsPage,
   scanPages,
+  matchRoute,
   renderPage,
   startDevServer
 };

package/dist/cli.js

@@ -1,19 +1,24 @@
 import {
+  createApiHandler,
+  createMcpHandler,
+  expandApiModule,
+  hasMcpRoutes,
   loadComponents,
+  matchRoute,
   renderIslandsPage,
   renderPage,
   scanPages,
   startDevServer
-} from "./chunk-GC3WNE6M.js";
+} from "./chunk-IEXQ7E5C.js";
 
 // src/cli.ts
-import { resolve as resolve4 } from "path";
-import { defineCommand as defineCommand5, runMain } from "citty";
+import { resolve as resolve5 } from "path";
+import { defineCommand as defineCommand6, runMain } from "citty";
 
 // src/commands/build.ts
-import { cpSync, existsSync, mkdirSync, rmSync, writeFileSync } from "fs";
-import { dirname, join as join2, resolve } from "path";
-import { apex as apex2 } from "@apex-stack/vite";
+import { cpSync, existsSync as existsSync2, mkdirSync, readdirSync as readdirSync2, rmSync, writeFileSync } from "fs";
+import { dirname, join as join3, resolve } from "path";
+import { apex as apex3 } from "@apex-stack/vite";
 import { defineCommand } from "citty";
 import { createServer as createViteServer } from "vite";
 
@@ -69,6 +74,65 @@ async function buildClient(root, routes, outDir) {
   return hrefs;
 }
 
+// src/build/buildServer.ts
+import { existsSync, readdirSync } from "fs";
+import { isAbsolute, join as join2 } from "path";
+import { apex as apex2 } from "@apex-stack/vite";
+import { build as build2 } from "vite";
+async function buildServer(root, routes, outDir) {
+  const ids = routes.map((r) => r.pageId);
+  const compDir = join2(root, "components");
+  if (existsSync(compDir)) {
+    for (const f of readdirSync(compDir).filter((f2) => f2.endsWith(".alpine"))) {
+      ids.push(`/components/${f}`);
+    }
+  }
+  const apiDir = join2(root, "server", "api");
+  if (existsSync(apiDir)) {
+    for (const f of readdirSync(apiDir).filter((f2) => /\.(ts|js|mjs)$/.test(f2))) {
+      ids.push(`/server/api/${f}`);
+    }
+  }
+  const input = {};
+  for (const id of ids) input[entryName2(id)] = join2(root, id.slice(1));
+  const result = await build2({
+    root,
+    logLevel: "warn",
+    plugins: [apex2({ clientRuntime: "@apex-stack/core/client" })],
+    build: {
+      ssr: true,
+      target: "esnext",
+      // Node target — allow top-level await in server modules
+      outDir: join2(outDir, "server"),
+      emptyOutDir: false,
+      rollupOptions: {
+        input,
+        // Externalize every package import (bare specifier) — deps are resolved at
+        // runtime from node_modules. Only the app's own relative/absolute files are
+        // bundled. This keeps native/workspace deps (@libsql/client, drizzle, …) out.
+        external: (id) => !id.startsWith(".") && !isAbsolute(id),
+        output: { format: "esm", entryFileNames: "[name].mjs" }
+      }
+    }
+  });
+  const byFacade = /* @__PURE__ */ new Map();
+  for (const chunk of result.output) {
+    if (chunk.type === "chunk" && chunk.isEntry && chunk.facadeModuleId) {
+      byFacade.set(chunk.facadeModuleId, chunk.fileName);
+    }
+  }
+  const modules = {};
+  for (const id of ids) {
+    const abs = join2(root, id.slice(1));
+    const file = byFacade.get(abs);
+    if (file) modules[id] = file;
+  }
+  return { modules };
+}
+function entryName2(id) {
+  return id.replace(/^\//, "").replace(/\.(alpine|ts|js|mjs)$/, "").replace(/[^a-zA-Z0-9]+/g, "_");
+}
+
 // src/commands/build.ts
 function outFile(pattern) {
   const clean = pattern.replace(/^\//, "");
@@ -79,7 +143,8 @@ var buildCommand = defineCommand({
   args: {
     root: { type: "positional", required: false, description: "Project root", default: "." },
     outDir: { type: "string", description: "Output directory", default: "dist" },
-    islands: { type: "boolean", description: "Static-first islands mode (zero-JS static)", default: false }
+    islands: { type: "boolean", description: "Static-first islands mode (zero-JS static)", default: false },
+    server: { type: "boolean", description: "Build a Node server (dynamic routes + API/MCP)", default: false }
   },
   async run({ args }) {
     const root = resolve(process.cwd(), args.root);
@@ -88,12 +153,15 @@ var buildCommand = defineCommand({
     const routes = scanPages(root);
     const staticRoutes = routes.filter((r) => !r.isDynamic);
     const dynamic = routes.filter((r) => r.isDynamic);
+    if (args.server) {
+      return buildServerTarget(root, outDir, args.outDir, routes);
+    }
     const hrefs = args.islands ? /* @__PURE__ */ new Map() : await buildClient(root, staticRoutes, outDir);
     const vite = await createViteServer({
       root,
       appType: "custom",
       server: { middlewareMode: true },
-      plugins: [apex2({ clientRuntime: "@apex-stack/core/client" })]
+      plugins: [apex3({ clientRuntime: "@apex-stack/core/client" })]
     });
     try {
       const { registry, css: componentCss } = await loadComponents(
@@ -109,13 +177,13 @@ var buildCommand = defineCommand({
           componentCss
         };
         const html = args.islands ? await renderIslandsPage(common) : await renderPage({ ...common, clientHref: hrefs.get(route.pageId) });
-        const dest = join2(outDir, outFile(route.pattern));
+        const dest = join3(outDir, outFile(route.pattern));
         mkdirSync(dirname(dest), { recursive: true });
         writeFileSync(dest, html);
         console.log(`  \u2713 ${route.pattern}  \u2192  ${outFile(route.pattern)}`);
       }
-      const pub = join2(root, "public");
-      if (existsSync(pub)) cpSync(pub, outDir, { recursive: true });
+      const pub = join3(root, "public");
+      if (existsSync2(pub)) cpSync(pub, outDir, { recursive: true });
       console.log(
         `
   Built ${staticRoutes.length} page(s) \u2192 ${args.outDir}/` + (args.islands ? " (islands / static-first)" : " (prerendered + hydrated)")
@@ -131,10 +199,49 @@ var buildCommand = defineCommand({
     }
   }
 });
+async function buildServerTarget(root, outDir, outLabel, routes) {
+  const clientHrefs = await buildClient(root, routes, outDir);
+  const server = await buildServer(root, routes, outDir);
+  const components = {};
+  const compDir = join3(root, "components");
+  if (existsSync2(compDir)) {
+    for (const f of readdirSync2(compDir).filter((f2) => f2.endsWith(".alpine"))) {
+      const sf = server.modules[`/components/${f}`];
+      if (sf) components[f.replace(/\.alpine$/, "")] = sf;
+    }
+  }
+  const api = [];
+  const apiDir = join3(root, "server", "api");
+  if (existsSync2(apiDir)) {
+    for (const f of readdirSync2(apiDir).filter((f2) => /\.(ts|js|mjs)$/.test(f2))) {
+      const sf = server.modules[`/server/api/${f}`];
+      if (sf) api.push({ name: f.replace(/\.(ts|js|mjs)$/, ""), serverFile: sf });
+    }
+  }
+  const manifest = {
+    islands: false,
+    routes: routes.map((r) => ({
+      ...r,
+      serverFile: server.modules[r.pageId],
+      clientHref: clientHrefs.get(r.pageId)
+    })),
+    components,
+    api
+  };
+  writeFileSync(join3(outDir, "apex-manifest.json"), JSON.stringify(manifest, null, 2));
+  const pub = join3(root, "public");
+  if (existsSync2(pub)) cpSync(pub, outDir, { recursive: true });
+  console.log(
+    `
+  Built server target \u2192 ${outLabel}/  (${routes.length} route(s), ${api.length} API module(s))
+  Run it:  apex start
+`
+  );
+}
 
 // src/commands/make.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
-import { dirname as dirname2, join as join3, resolve as resolve2 } from "path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname2, join as join4, resolve as resolve2 } from "path";
 import { defineCommand as defineCommand2 } from "citty";
 function pageTemplate(name) {
   return `<script server lang="ts">
@@ -181,11 +288,11 @@ export default defineApexRoute({
 function plan(kind, name, root) {
   switch (kind) {
     case "page":
-      return { path: join3(root, "pages", `${name}.alpine`), contents: pageTemplate(name) };
+      return { path: join4(root, "pages", `${name}.alpine`), contents: pageTemplate(name) };
     case "component":
-      return { path: join3(root, "components", `${name}.alpine`), contents: componentTemplate() };
+      return { path: join4(root, "components", `${name}.alpine`), contents: componentTemplate() };
     case "api":
-      return { path: join3(root, "server", "api", `${name}.ts`), contents: apiTemplate(name) };
+      return { path: join4(root, "server", "api", `${name}.ts`), contents: apiTemplate(name) };
   }
 }
 var makeCommand = defineCommand2({
@@ -205,7 +312,7 @@ var makeCommand = defineCommand2({
     }
     const root = resolve2(process.cwd(), args.root);
     const { path, contents } = plan(kind, args.name, root);
-    if (existsSync2(path)) {
+    if (existsSync3(path)) {
       console.error(`
   \u2717 Already exists: ${path}
 `);
@@ -275,13 +382,15 @@ var mcpCommand = defineCommand3({
 
 // src/commands/migrate.ts
 import { createRequire } from "module";
-import { join as join4, resolve as resolve3 } from "path";
+import { join as join5, resolve as resolve3 } from "path";
 import { pathToFileURL } from "url";
 import { defineCommand as defineCommand4 } from "citty";
 var migrateCommand = defineCommand4({
   meta: { name: "migrate", description: "Apply pending SQL migrations (db/migrations/*.sql)" },
   args: {
-    db: { type: "string", description: "SQLite file path", default: "data.db" },
+    db: { type: "string", description: "SQLite file path (libSQL)", default: "data.db" },
+    driver: { type: "string", description: "sqlite | postgres | pglite", default: "sqlite" },
+    url: { type: "string", description: "Connection URL (postgres) \u2014 overrides --db" },
     dir: { type: "string", description: "Migrations directory", default: "db/migrations" },
     root: { type: "string", description: "Project root", default: "." }
   },
@@ -289,14 +398,16 @@ var migrateCommand = defineCommand4({
     const root = resolve3(process.cwd(), args.root);
     let data;
     try {
-      const require2 = createRequire(join4(root, "package.json"));
+      const require2 = createRequire(join5(root, "package.json"));
       data = await import(pathToFileURL(require2.resolve("@apex-stack/data")).href);
     } catch {
       console.error("\n  @apex-stack/data is not installed in this project. Run: npm i @apex-stack/data\n");
       process.exit(1);
     }
-    const { sqlite } = data.createDb(resolve3(root, args.db));
-    const applied = data.applyMigrations(sqlite, resolve3(root, args.dir));
+    const config = args.driver === "postgres" ? { driver: "postgres", url: args.url } : args.driver === "pglite" ? { driver: "pglite", dir: args.url } : resolve3(root, args.db);
+    const handle = await data.createDb(config);
+    const applied = await data.applyMigrations(handle, resolve3(root, args.dir));
+    await handle.close();
     console.log(
       applied.length ? `
   \u2713 Applied ${applied.length} migration(s): ${applied.join(", ")}
@@ -305,8 +416,126 @@ var migrateCommand = defineCommand4({
   }
 });
 
+// src/commands/start.ts
+import { existsSync as existsSync5 } from "fs";
+import { join as join7, resolve as resolve4 } from "path";
+import { defineCommand as defineCommand5 } from "citty";
+
+// src/prod/server.ts
+import { createServer as createHttpServer } from "http";
+import { existsSync as existsSync4, readFileSync as readFileSync2, statSync } from "fs";
+import { join as join6 } from "path";
+import { pathToFileURL as pathToFileURL2 } from "url";
+import {
+  createApp,
+  defineEventHandler,
+  getRequestURL,
+  setResponseHeader,
+  setResponseStatus,
+  toNodeListener
+} from "h3";
+var MIME = {
+  ".js": "text/javascript",
+  ".mjs": "text/javascript",
+  ".css": "text/css",
+  ".html": "text/html",
+  ".json": "application/json",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".ico": "image/x-icon",
+  ".woff2": "font/woff2"
+};
+async function startProdServer(options) {
+  const dir = options.dir;
+  const port = options.port ?? 3e3;
+  const manifest = JSON.parse(readFileSync2(join6(dir, "apex-manifest.json"), "utf8"));
+  const importServer = (relFile) => import(pathToFileURL2(join6(dir, "server", relFile)).href);
+  const registry = {};
+  let componentCss = "";
+  for (const [name, file] of Object.entries(manifest.components)) {
+    const mod = await importServer(file);
+    registry[name] = { template: mod.template, rootXData: mod.rootXData, scopeId: mod.scopeId };
+    if (mod.css) componentCss += `${mod.css}
+`;
+  }
+  const apiEntries = [];
+  for (const { name, serverFile } of manifest.api) {
+    const mod = await importServer(serverFile);
+    apiEntries.push(...expandApiModule(name, mod.default));
+  }
+  const serverFileFor = new Map(manifest.routes.map((r) => [r.pageId, r.serverFile]));
+  const loadModule = (id) => importServer(serverFileFor.get(id));
+  const app = createApp();
+  app.use(
+    defineEventHandler((event) => {
+      if (event.method !== "GET") return;
+      const path = decodeURIComponent(getRequestURL(event).pathname);
+      if (path === "/" || path.startsWith("/api") || path === "/mcp") return;
+      const file = join6(dir, path);
+      if (!file.startsWith(dir) || !existsSync4(file) || !statSync(file).isFile()) return;
+      const ext = path.slice(path.lastIndexOf("."));
+      setResponseHeader(event, "Content-Type", MIME[ext] ?? "application/octet-stream");
+      if (path.startsWith("/assets/")) setResponseHeader(event, "Cache-Control", "public, max-age=31536000, immutable");
+      return readFileSync2(file);
+    })
+  );
+  if (apiEntries.length) app.use("/api", createApiHandler(apiEntries));
+  if (hasMcpRoutes(apiEntries)) app.use("/mcp", createMcpHandler(apiEntries));
+  app.use(
+    defineEventHandler(async (event) => {
+      const url = getRequestURL(event).pathname;
+      const matched = matchRoute(manifest.routes, url);
+      if (!matched) {
+        setResponseStatus(event, 404);
+        setResponseHeader(event, "Content-Type", "text/html");
+        return `<!DOCTYPE html><h1>404 \u2014 ${url}</h1>`;
+      }
+      const route = manifest.routes.find((r) => r.pageId === matched.pageId);
+      const render = manifest.islands ? renderIslandsPage : renderPage;
+      const html = await render({
+        loadModule,
+        pageId: matched.pageId,
+        params: matched.params,
+        url,
+        registry,
+        componentCss,
+        clientHref: route?.clientHref
+      });
+      setResponseHeader(event, "Content-Type", "text/html");
+      return html;
+    })
+  );
+  const server = createHttpServer(toNodeListener(app));
+  await new Promise((resolve6) => server.listen(port, resolve6));
+  return { server, port };
+}
+
+// src/commands/start.ts
+var startCommand = defineCommand5({
+  meta: { name: "start", description: "Run a production build (from `apex build --server`)" },
+  args: {
+    dir: { type: "positional", required: false, description: "Build directory", default: "dist" },
+    port: { type: "string", description: "Port to listen on", default: "3000" }
+  },
+  async run({ args }) {
+    const dir = resolve4(process.cwd(), args.dir);
+    if (!existsSync5(join7(dir, "apex-manifest.json"))) {
+      console.error(`
+  No build found in ${args.dir}/. Run \`apex build --server\` first.
+`);
+      process.exit(1);
+    }
+    const { port } = await startProdServer({ dir, port: Number(args.port) });
+    console.log(`
+  \x1B[36mApex JS\x1B[0m production server
+  \u2192 http://localhost:${port}
+`);
+  }
+});
+
 // src/cli.ts
-var dev = defineCommand5({
+var dev = defineCommand6({
   meta: { name: "dev", description: "Start the Apex JS development server" },
   args: {
     root: { type: "positional", required: false, description: "Project root", default: "." },
@@ -314,7 +543,7 @@ var dev = defineCommand5({
     islands: { type: "boolean", description: "Render in islands mode (static-first)", default: false }
   },
   async run({ args }) {
-    const root = resolve4(process.cwd(), args.root);
+    const root = resolve5(process.cwd(), args.root);
     const port = Number(args.port);
     const { port: actual } = await startDevServer({ root, port, islands: args.islands });
     console.log(`
@@ -323,7 +552,7 @@ var dev = defineCommand5({
 `);
   }
 });
-var main = defineCommand5({
+var main = defineCommand6({
   meta: {
     name: "apex",
     description: "The full-stack meta-framework for Alpine.js"
@@ -331,6 +560,7 @@ var main = defineCommand5({
   subCommands: {
     dev,
     build: buildCommand,
+    start: startCommand,
     make: makeCommand,
     migrate: migrateCommand,
     mcp: mcpCommand

package/dist/index.js

@@ -2,7 +2,7 @@ import {
   isApexResource,
   renderPage,
   startDevServer
-} from "./chunk-GC3WNE6M.js";
+} from "./chunk-IEXQ7E5C.js";
 
 // src/api/defineRoute.ts
 function defineApexRoute(config) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apex-stack/core",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "The full-stack meta-framework for Alpine.js — CLI and runtime",
   "type": "module",
   "license": "MIT",