@junejs/server 0.0.15 → 0.0.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@junejs/server",
-  "version": "0.0.15",
+  "version": "0.0.17",
   "description": "June host adapters + dev server. Host-coupled; depends on the pure @junejs/core contract layer.",
   "type": "module",
   "license": "MIT",
@@ -30,8 +30,8 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@junejs/core": "0.0.15",
-    "@junejs/db": "0.0.15",
+    "@junejs/core": "0.0.17",
+    "@junejs/db": "0.0.17",
     "marked": "^18.0.5",
     "rolldown": "^1.1.0",
     "postcss": "^8.4.0",
@@ -40,10 +40,25 @@
   },
   "peerDependencies": {
     "react": "^19.2.0",
-    "react-dom": "^19.2.0"
+    "react-dom": "^19.2.0",
+    "pg": "^8.0.0",
+    "mysql2": "^3.0.0"
+  },
+  "peerDependenciesMeta": {
+    "pg": {
+      "optional": true
+    },
+    "mysql2": {
+      "optional": true
+    }
   },
   "repository": {
     "type": "git",
     "url": "https://github.com/junebuild/june"
+  },
+  "devDependencies": {
+    "@types/pg": "^8.20.0",
+    "mysql2": "^3.22.5",
+    "pg": "^8.21.0"
   }
 }

package/src/adapter.ts

@@ -136,26 +136,44 @@ export function workers(opts?: { name?: string; domain?: string }): JuneAdapter
 
 // Vercel target — emits the Build Output API v3 tree (.vercel/output/). June's
 // worker is already a Web-standard fetch handler, so this is packaging, not a
-// re-bundle: the same portable graph, built with edge-light conditions, becomes a
-// Vercel Edge Function. v1 scope: SSR + static + the full agent surface. No db
-// (D1 is Cloudflare-only) — declaring one fails fast; an HTTP-driver db backend
-// for Vercel is a planned follow-up.
+// re-bundle: the same portable graph (built with edge-light conditions, so
+// react-dom resolves to server.edge.js) packaged for the platform.
+//
+// Default runtime is "node" — a Vercel Function on Fluid compute. Vercel
+// deprecated the Edge Functions *product* and officially recommends the Node
+// runtime for performance + reliability, and Fluid compute (in-function
+// concurrency) closed the cold-start gap edge used to win on. Node also lifts
+// edge's limits (no 1–4MB code cap, full API) and is the substrate a future
+// HTTP/TCP db backend (Neon/Turso) needs. `vercel({ runtime: "edge" })` still
+// emits an Edge Function for latency-critical global cases — the runtime is not
+// removed, just discouraged. BOTH run the SAME bundle; only the .func packaging
+// (.vc-config.json + the export shape) differs.
+//
+// No db yet (D1 is Cloudflare-only) — declaring one still fails fast; the Node
+// runtime makes a real backend possible but it isn't wired here.
 //
 // Routing: only the hashed framework assets (/_june/*) are served statically by
 // the CDN (their exact-path URLs match June's scheme); every page + projection
-// (.md/.json/mcp/llms.txt) renders through the one edge function, so the
-// dual-audience surface is identical to Workers.
+// (.md/.json/mcp/llms.txt) renders through the one function, so the dual-audience
+// surface is identical to Workers.
 const VERCEL_FUNCTION = "__june"; // → /__june, the catch-all SSR function
 
-export function vercel(opts?: { regions?: string[] }): JuneAdapter {
+export function vercel(opts?: { runtime?: "node" | "edge"; regions?: string[] }): JuneAdapter {
+  const isEdge = (opts?.runtime ?? "node") === "edge";
   return {
     name: "vercel",
-    capabilities: { runtime: "edge", persistentConnections: false, assets: "platform" },
-    // NO "worker"/"browser": react-dom's ./server exports map "worker" → the
-    // BROWSER SSR build (server.browser.js), listed BEFORE "edge-light", so
-    // requesting "worker" pulls the wrong renderer and the edge function crashes
-    // at invocation. "edge-light" → server.edge.js (the same build workerd gets
-    // via "workerd"). Mirrors workers()'s shape: <runtime>, edge, import, default.
+    capabilities: {
+      // Node on Fluid holds streamed/SSE connections; the edge variant keeps the
+      // conservative flag it shipped with.
+      runtime: isEdge ? "edge" : "node",
+      persistentConnections: !isEdge,
+      assets: "platform",
+    },
+    // The bundle is identical for both runtimes. NO "worker"/"browser": react-dom's
+    // ./server exports map "worker" → the BROWSER SSR build (server.browser.js),
+    // listed BEFORE "edge-light", so requesting "worker" pulls the wrong renderer.
+    // "edge-light" → server.edge.js, which uses Web Streams (renderToReadableStream)
+    // and runs on workerd AND Node alike. Mirrors workers()'s shape.
     conditions: ["edge-light", "edge", "import", "default"],
 
     validate({ plan }) {
@@ -170,13 +188,17 @@ export function vercel(opts?: { regions?: string[] }): JuneAdapter {
 
     entry() {
       // No withAssets: the CDN serves /_june/*; this function renders everything
-      // else. Resources arrive via process.env (Vercel injects env vars into the
-      // edge runtime); there are no platform bindings.
+      // else. Resources arrive via process.env (Vercel injects env vars); there
+      // are no platform bindings. The Node runtime captures the `fetch` Web
+      // Standard export (an object with a fetch method); the Edge runtime takes a
+      // bare default function. Same pipeline call either way.
+      const env = `const __env = typeof process !== "undefined" && process.env ? process.env : {};\n`;
       return {
         imports: [],
         wrap: (pipelineVar) =>
-          `const __env = typeof process !== "undefined" && process.env ? process.env : {};\n` +
-          `export default (request) => ${pipelineVar}.fetch(request, __env);`,
+          isEdge
+            ? env + `export default (request) => ${pipelineVar}.fetch(request, __env);`
+            : env + `export default { fetch: (request) => ${pipelineVar}.fetch(request, __env) };`,
       };
     },
 
@@ -192,14 +214,28 @@ export function vercel(opts?: { regions?: string[] }): JuneAdapter {
       // function ("referencing unsupported modules"). assets/ is handled below.
       const jsFiles = (await readdir(outDir)).filter((f) => f.endsWith(".js"));
       for (const f of jsFiles) await copyFile(join(outDir, f), join(fnDir, f));
-      await writeFile(
-        join(fnDir, ".vc-config.json"),
-        JSON.stringify(
-          { runtime: "edge", entrypoint: "worker.js", ...(opts?.regions ? { regions: opts.regions } : {}) },
-          null,
-          2,
-        ) + "\n",
-      );
+
+      const regions = opts?.regions ? { regions: opts.regions } : {};
+      const vcConfig = isEdge
+        ? { runtime: "edge", entrypoint: "worker.js", ...regions }
+        : {
+            // A Vercel Function on Fluid compute. handler = the ESM bundle entry;
+            // launcherType Nodejs invokes its default `fetch` export.
+            // supportsResponseStreaming is REQUIRED or a streamed Response (our SSE
+            // live feed, streamed SSR) is buffered instead of flushed.
+            runtime: "nodejs22.x",
+            handler: "worker.js",
+            launcherType: "Nodejs",
+            supportsResponseStreaming: true,
+            ...regions,
+          };
+      await writeFile(join(fnDir, ".vc-config.json"), JSON.stringify(vcConfig, null, 2) + "\n");
+      // The bundle is ESM (worker.js + ./chunk-*.js all use `export`/`import`).
+      // The Node runtime loads the .func as CommonJS by default, so mark the whole
+      // function dir as ESM. (The edge runtime always treats sources as ESM.)
+      if (!isEdge) {
+        await writeFile(join(fnDir, "package.json"), JSON.stringify({ type: "module" }, null, 2) + "\n");
+      }
 
       // static: only the hashed framework assets under /_june/ (exact-path URLs)
       if (hasAssets) {

package/src/d1.ts

@@ -26,6 +26,7 @@ export interface D1Database {
 // already-bound D1Database.
 export function d1(binding: D1Database): DbFactory {
   const db: JuneDb = {
+    dialect: "sqlite", // D1 *is* sqlite — same SQL, same Juno compiler
     async query<T>(sql: string, params: unknown[] = []) {
       return (await binding.prepare(sql).bind(...params).all<T>()).results;
     },

package/src/db.ts

@@ -16,6 +16,8 @@ import type { DbFactory } from "@junejs/core/resources";
 import { host } from "./host";
 
 export { d1, type D1Database } from "./d1";
+export { postgres, pgJuneDb, type PgClientLike } from "./postgres-driver";
+export { mysql, mysqlJuneDb, type MysqlConnLike } from "./mysql-driver";
 
 // Local SQLite — the zero-config dev default. A persistent FILE, not :memory:,
 // on purpose: `june dev` restarts the process on every save (the watch

package/src/index.ts

@@ -11,7 +11,7 @@ export {
   type AdapterEmitContext,
 } from "./adapter";
 export { host, type JuneHost, type JuneDb, type RunResult, type ServeHandle, type SpawnedModule } from "./host";
-export { sqlite, d1, type D1Database } from "./db";
+export { sqlite, d1, postgres, mysql, type D1Database } from "./db";
 export { memoryKv, redisKv } from "./kv";
 export { localBlob, r2, type R2Bucket } from "./blob";
 export {
@@ -29,6 +29,7 @@ export { loadJuneConfig } from "./config-loader";
 export {
   migrate,
   migrateApp,
+  typesApp,
   classify,
   readMigrations,
   blockedMessage,

package/src/migrate.ts

@@ -112,6 +112,24 @@ export async function migrateApp(
   }
 }
 
+// `june db types`: open the declared db, bring it to head (safe migrations only, so
+// the schema is present even on a fresh checkout), then hand it to the data layer's
+// codegen hook for the type-declaration text. Returns null when there's no db or the
+// data layer doesn't generate types — the CLI owns the messaging. Introspection is
+// read-only; the safe migrate is idempotent (the ledger skips applied ones).
+export async function typesApp(root: string, config: JuneConfig): Promise<string | null> {
+  const factory = config.resources?.db;
+  const emit = config.dataLayer?.emitTypes;
+  if (!factory || !emit) return null;
+  const db = await factory.open();
+  try {
+    await migrate(db, join(root, "db", "migrations"), { allowDestructive: false });
+    return await emit(db);
+  } finally {
+    await db.close();
+  }
+}
+
 // The "this migration was gated" guidance, shared by dev (warns, keeps serving)
 // and `june db migrate` (exits non-zero).
 export function blockedMessage(m: ClassifiedMigration): string {

package/src/mysql-driver.ts

@@ -0,0 +1,68 @@
+// MySQL `db` adapter — implements the @junejs/core JuneDb contract over `mysql2`.
+// Tags itself `dialect: "mysql"` so Juno compiles backtick / `?` / ON DUPLICATE KEY
+// SQL for it. `mysql2` is dynamically imported (a peer the app installs only when it
+// declares `mysql()`). Test/dev grade: ONE connection per open(); pooling / env
+// binding come later.
+
+import type { DbFactory, JuneDb, RunResult } from "@junejs/core/resources";
+
+// mysql2 returns [rows, fields]; a write yields a ResultSetHeader as the first element.
+interface OkHeader {
+  affectedRows?: number;
+  insertId?: number;
+}
+// The slice of mysql2/promise's Connection we depend on — so mysqlJuneDb is fakeable.
+export interface MysqlConnLike {
+  query(sql: string, params?: unknown[]): Promise<[unknown, unknown]>;
+  end(): Promise<void>;
+}
+
+// Wrap a mysql2 connection as a JuneDb. Exported for offline unit tests.
+export function mysqlJuneDb(conn: MysqlConnLike): JuneDb {
+  const self: JuneDb = {
+    dialect: "mysql",
+    async query<T>(sql: string, params: unknown[] = []) {
+      return (await conn.query(sql, params))[0] as T[];
+    },
+    async get<T>(sql: string, params: unknown[] = []) {
+      const rows = (await conn.query(sql, params))[0] as unknown[];
+      return (rows[0] ?? undefined) as T | undefined;
+    },
+    async run(sql: string, params: unknown[] = []): Promise<RunResult> {
+      const header = (await conn.query(sql, params))[0] as OkHeader;
+      return { changes: header.affectedRows ?? 0, lastInsertRowid: header.insertId ?? 0 };
+    },
+    async exec(sql: string) {
+      await conn.query(sql); // needs multipleStatements for a multi-statement script
+    },
+    async transaction<T>(fn: (tx: JuneDb) => Promise<T>) {
+      await conn.query("begin");
+      try {
+        const out = await fn(self);
+        await conn.query("commit");
+        return out;
+      } catch (e) {
+        await conn.query("rollback");
+        throw e;
+      }
+    },
+    async close() {
+      await conn.end();
+    },
+  };
+  return self;
+}
+
+// `mysql({ url })` — multipleStatements is on so exec() can run a whole migration file.
+export function mysql(opts: { url: string }): DbFactory {
+  return {
+    kind: "mysql",
+    open: async () => {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const mod = (await import("mysql2/promise")) as any;
+      const create = (mod.default ?? mod).createConnection;
+      const conn = await create({ uri: opts.url, multipleStatements: true });
+      return mysqlJuneDb(conn);
+    },
+  };
+}

package/src/postgres-driver.ts

@@ -0,0 +1,67 @@
+// Postgres `db` adapter — implements the @junejs/core JuneDb contract over
+// node-postgres (`pg`). Tags itself `dialect: "postgres"` so Juno compiles `$n` /
+// double-quoted SQL for it (see @junejs/juno's dialectFor). `pg` is dynamically
+// imported, so it's a peer the app installs only when it declares `postgres()` — the
+// host never hard-depends on it. Test/dev grade: ONE connection per open(); pooling /
+// env binding / deploy adapters come in a later step.
+
+import type { DbFactory, JuneDb, RunResult } from "@junejs/core/resources";
+
+// The slice of `pg`'s Client we depend on — so pgJuneDb is unit-testable with a fake.
+export interface PgClientLike {
+  query(sql: string, params?: unknown[]): Promise<{ rows: unknown[]; rowCount: number | null }>;
+  end(): Promise<void>;
+}
+
+// Wrap a connected pg client as a JuneDb. Exported (not just the factory) so the
+// mapping — rows, first-row, RunResult, transaction ordering — is testable offline.
+export function pgJuneDb(client: PgClientLike): JuneDb {
+  const self: JuneDb = {
+    dialect: "postgres",
+    async query<T>(sql: string, params: unknown[] = []) {
+      return (await client.query(sql, params)).rows as T[];
+    },
+    async get<T>(sql: string, params: unknown[] = []) {
+      return ((await client.query(sql, params)).rows[0] ?? undefined) as T | undefined;
+    },
+    async run(sql: string, params: unknown[] = []): Promise<RunResult> {
+      const r = await client.query(sql, params);
+      // Postgres has no autoincrement rowid — callers use `RETURNING id`. Report the
+      // affected-row count; lastInsertRowid is 0 (not meaningful on PG).
+      return { changes: r.rowCount ?? 0, lastInsertRowid: 0 };
+    },
+    async exec(sql: string) {
+      await client.query(sql); // DDL / multi-statement via the simple-query protocol
+    },
+    async transaction<T>(fn: (tx: JuneDb) => Promise<T>) {
+      await client.query("begin");
+      try {
+        const out = await fn(self); // same connection
+        await client.query("commit");
+        return out;
+      } catch (e) {
+        await client.query("rollback");
+        throw e;
+      }
+    },
+    async close() {
+      await client.end();
+    },
+  };
+  return self;
+}
+
+// `postgres({ url })` — declared in june.config.ts; opened by the host.
+export function postgres(opts: { url: string }): DbFactory {
+  return {
+    kind: "postgres",
+    open: async () => {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const mod = (await import("pg")) as any;
+      const Client = (mod.default ?? mod).Client;
+      const client = new Client({ connectionString: opts.url });
+      await client.connect();
+      return pgJuneDb(client);
+    },
+  };
+}

package/src/sqlite-driver.ts

@@ -51,6 +51,7 @@ function asyncSqlite(db: SyncSqlite): JuneDb {
     return s;
   };
   const self: JuneDb = {
+    dialect: "sqlite",
     async query<T>(sql: string, params: unknown[] = []) {
       return prep(sql).all(...params) as T[];
     },