@junejs/server 0.0.17 → 0.0.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@junejs/server",
-  "version": "0.0.17",
+  "version": "0.0.18",
   "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.17",
-    "@junejs/db": "0.0.17",
+    "@junejs/core": "0.0.18",
+    "@junejs/db": "0.0.18",
     "marked": "^18.0.5",
     "rolldown": "^1.1.0",
     "postcss": "^8.4.0",
@@ -42,7 +42,8 @@
     "react": "^19.2.0",
     "react-dom": "^19.2.0",
     "pg": "^8.0.0",
-    "mysql2": "^3.0.0"
+    "mysql2": "^3.0.0",
+    "@libsql/client": "^0.14.0 || ^0.15.0 || ^0.16.0 || ^0.17.0"
   },
   "peerDependenciesMeta": {
     "pg": {
@@ -50,6 +51,9 @@
     },
     "mysql2": {
       "optional": true
+    },
+    "@libsql/client": {
+      "optional": true
     }
   },
   "repository": {
@@ -57,6 +61,7 @@
     "url": "https://github.com/junebuild/june"
   },
   "devDependencies": {
+    "@libsql/client": "^0.17.3",
     "@types/pg": "^8.20.0",
     "mysql2": "^3.22.5",
     "pg": "^8.21.0"

package/src/adapter.ts

@@ -143,14 +143,14 @@ export function workers(opts?: { name?: string; domain?: string }): JuneAdapter
 // 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
+// edge's limits (no 1–4MB code cap, full API). `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.
+// db: turso() works (libsql over HTTPS — the build bundles the web client, the
+// request opens it from env → ambient `import { db }`). sqlite()/d1() are
+// Cloudflare-only (a D1 binding); validate() rejects them with that guidance.
 //
 // Routing: only the hashed framework assets (/_june/*) are served statically by
 // the CDN (their exact-path URLs match June's scheme); every page + projection
@@ -176,12 +176,15 @@ export function vercel(opts?: { runtime?: "node" | "edge"; regions?: string[] })
     // and runs on workerd AND Node alike. Mirrors workers()'s shape.
     conditions: ["edge-light", "edge", "import", "default"],
 
-    validate({ plan }) {
-      if (plan.db) {
+    validate({ config }) {
+      // turso() is libsql over HTTPS — it runs on Vercel (the build bundles the web
+      // client; the request opens it from env → ambient `import { db }`). sqlite()/
+      // d1() need a D1 binding, which is Cloudflare-only.
+      const kind = config.resources?.db?.kind;
+      if (kind && kind !== "turso") {
         throw new Error(
-          "vercel(): the Vercel adapter has no db backend yet (D1 is Cloudflare-only).\n" +
-            "  Remove the `db` resource from june.config.ts, or deploy to Workers.\n" +
-            "  An HTTP-driver db (Neon/Turso) for Vercel is planned.",
+          `vercel(): the '${kind}' db isn't supported on Vercel (D1 is Cloudflare-only).\n` +
+            "  Use turso() (libsql over HTTPS) for a Vercel db, or deploy to Workers.",
         );
       }
     },

package/src/build.ts

@@ -378,12 +378,25 @@ export async function juneBuild(
     kv: !!resourcesCfg?.kv,
     blob: !!resourcesCfg?.blob,
   };
-  if (hasResources) {
+  // Two SQLite-dialect defaults, picked by the declared db's kind:
+  //   turso()         → libsql over HTTPS, connected from env (TURSO_*) via the
+  //                     bundled web client. Open the declared factory directly so it
+  //                     feeds the ambient `import { db }` scope (re-emitted by kind,
+  //                     not imported from the app config, to avoid the host barrel).
+  //   sqlite()/d1()   → a D1 binding from env (env.DB), via bindWorkerResources.
+  // (kv/blob on a turso deploy aren't wired yet — db-only.)
+  const tursoDb = resourcesCfg?.db?.kind === "turso";
+  if (tursoDb) {
+    imports.push(`import { turso } from "@junejs/server/db";`);
+    imports.push(`import { memoizeResources } from "@junejs/server/resources";`);
+  } else if (hasResources) {
     imports.push(`import { bindWorkerResources } from "@junejs/server/resources";`);
   }
-  const resourcesField = hasResources
-    ? `\n  resources: bindWorkerResources(${JSON.stringify(resourceFlags)}),`
-    : "";
+  const resourcesField = tursoDb
+    ? `\n  resources: memoizeResources({ db: turso() }),`
+    : hasResources
+      ? `\n  resources: bindWorkerResources(${JSON.stringify(resourceFlags)}),`
+      : "";
 
   // Opt-in Tier-3 data layer: import its installDataLayer from the declared module
   // and call it at worker boot — the prod twin of the dev host's dataLayer.install()
@@ -521,10 +534,12 @@ ${adapterEntry.wrap("pipeline")}
     ? (JSON.parse(await Bun.file(pkgPath).text()) as { name?: string }).name
     : undefined;
   const defaultName = (pkgName ?? basename(appRoot)).replace(/[^a-z0-9-]/gi, "-").toLowerCase();
-  // A declared `db` → a D1 binding named DB (the name bindWorkerResources reads).
-  const plan: ResourcePlan = resourcesCfg?.db
-    ? { db: { binding: "DB", databaseName: `${defaultName}-db` } }
-    : {};
+  // A declared D1-backed db (sqlite/d1) → a D1 binding named DB (the name
+  // bindWorkerResources reads). turso() connects from env, not a binding — no plan.
+  const plan: ResourcePlan =
+    resourcesCfg?.db && resourcesCfg.db.kind !== "turso"
+      ? { db: { binding: "DB", databaseName: `${defaultName}-db` } }
+      : {};
   await adapter.emit({ appRoot, outDir, hasAssets, linkHeader, config: fullConfig, plan, defaultName });
   if (plan.db) {
     console.log(

package/src/db.ts

@@ -1,35 +1,38 @@
 // `db` resource adapters — implementations of the @junejs/core JuneDb contract.
 // Declared in june.config.ts (`resources.db: sqlite(...)` / `d1(...)`), opened
-// by the host, injected onto RouteContext as `ctx.db`. The framework depends on
-// the JuneDb contract; these adapters (and Juno on top) are swappable.
+// by the host and made ambient (`import { db } from "@junejs/db"`, via
+// runInScope — NOT on ctx). The framework depends on the JuneDb contract; these
+// adapters (and Juno on top) are swappable.
 //
-// sqlite() is host-coupled (node:fs + ./host) and DEV-only. The edge-safe d1()
-// adapter lives in ./d1 so the generated worker can import it without dragging
-// this module's host imports into the workerd bundle; it is re-exported here so
-// `@junejs/server/db` stays the one place both db adapters are named.
-
-import { mkdirSync } from "node:fs";
-import { dirname } from "node:path";
+// This module is HOST-FREE so the generated worker can import it (e.g. `turso`)
+// without dragging node:fs / the dev host into the bundle (reminder #4). The two
+// host-coupled adapters keep their host touch out of the static graph:
+//   - d1()    lives in ./d1 (edge-safe; env binding).
+//   - sqlite() is DEV-only and imports node:fs + ./host LAZILY, inside open().
+// All five (sqlite/d1/postgres/mysql/turso) are named from this one place.
 
 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";
+export { turso, libsqlJuneDb, type LibsqlClientLike } from "./turso-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
 // 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.
+// for ephemerality. node:fs + ./host are imported lazily so this module stays
+// host-free (sqlite() only runs in dev, where the imports resolve).
 export function sqlite(opts: { path?: string } = {}): DbFactory {
   const path = opts.path ?? ".june/dev.sqlite";
   return {
     kind: "sqlite",
-    open: () => {
+    open: async () => {
+      const { mkdirSync } = await import("node:fs");
+      const { dirname } = await import("node:path");
+      const { host } = await import("./host");
       if (path !== ":memory:") mkdirSync(dirname(path), { recursive: true });
       return host.openDb(path);
     },

package/src/host.ts

@@ -49,7 +49,7 @@ export interface JuneHost {
   // this with the in-isolate dual-graph loader; the seam stays for the fallback.
   spawnModule(entry: string, args: string[], opts: { conditions?: string[] }): SpawnedModule;
   // Open a LOCAL SQLite database — the internal primitive the `sqlite()` db
-  // adapter builds on (docs/data-layer-boundary.md: openDb is demoted from the
+  // adapter builds on (docs/data-layer.md: openDb is demoted from the
   // user-facing API to a host primitive; apps declare `resources.db` instead).
   openDb(path: string): Promise<JuneDb>;
 }

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, postgres, mysql, type D1Database } from "./db";
+export { sqlite, d1, postgres, mysql, turso, type D1Database } from "./db";
 export { memoryKv, redisKv } from "./kv";
 export { localBlob, r2, type R2Bucket } from "./blob";
 export {

package/src/kv.ts

@@ -1,4 +1,4 @@
-// `kv` resource adapters. The kv resource IS the cache (docs/data-layer-boundary
+// `kv` resource adapters. The kv resource IS the cache (docs/data-layer
 // .md: "reframe cache as the kv resource — it already is one"): these wrap
 // @junejs/core/cache's CacheStore (memory / redis) as the simpler JuneKv contract,
 // so there is ONE key-value system, surfaced both as cache() and as ambient kv.

package/src/resources.ts

@@ -1,7 +1,9 @@
 // Resource resolution — open the handles declared in june.config.ts `resources`
-// and hand them to the pipeline, which injects them onto RouteContext (ctx.db /
-// ctx.kv / ctx.blob). A resource not declared is never opened (and, for static
-// apps, tree-shaken out — the build freeze knows which routes touch resources).
+// and hand them to the pipeline, which runs each request inside runInScope() so
+// they resolve AMBIENTLY (`import { db } from "@junejs/db"`). ctx never carries
+// them — ctx is identity-only (see route.ts). A resource not declared is never
+// opened (and, for static apps, tree-shaken out — the build freeze knows which
+// routes touch resources).
 
 import type { ResourceConfig, Resources } from "@junejs/core/resources";
 
@@ -48,7 +50,7 @@ export type ResourceFlags = { db?: boolean; kv?: boolean; blob?: boolean };
 // from env (env.DB → D1) — the prod half of "sqlite dev → D1 prod, one
 // declaration": the same `resources: { db: sqlite() }` runs on D1 at the edge,
 // because D1 *is* SQLite (same SQL, same Juno tables). No env binding → the
-// handle is absent and the route degrades (ctx.db undefined), never a crash.
+// handle is absent and the route degrades (ambient `db` unavailable), never a crash.
 // Memoized per isolate (env is stable across requests in a workerd isolate).
 //
 // env is typed `unknown` (it arrives untyped from the runtime) and narrowed to

package/src/turso-driver.ts

@@ -0,0 +1,96 @@
+// Turso / libsql `db` adapter — implements the @junejs/core JuneDb contract over
+// @libsql/client. Turso speaks libsql (SQLite over an HTTPS endpoint), so it tags
+// itself `dialect: "sqlite"`: Juno compiles the exact same `?`-placeholder SQLite
+// SQL it uses for the local sqlite() adapter, and the connection is a plain URL +
+// token (no TCP socket, no platform binding) — so it runs on the Vercel Node
+// runtime, on edge, and anywhere with fetch. `@libsql/client` is dynamically
+// imported: a peer the app installs only when it declares turso(); the host never
+// hard-depends on it. Host-free (no node:* / ./host) so it can enter a worker
+// bundle, unlike sqlite().
+
+import type { DbFactory, JuneDb, RunResult } from "@junejs/core/resources";
+
+// The slice of @libsql/client's Client we depend on — so libsqlJuneDb is
+// unit-testable with a fake (no network).
+export interface LibsqlResultSet {
+  rows: unknown[];
+  rowsAffected: number;
+  lastInsertRowid?: bigint | number;
+}
+export interface LibsqlClientLike {
+  execute(stmt: { sql: string; args?: unknown[] } | string): Promise<LibsqlResultSet>;
+  executeMultiple?(sql: string): Promise<void>;
+  close(): void | Promise<void>;
+}
+
+// Wrap a libsql client as a JuneDb. Exported (not just the factory) so the mapping
+// — rows, first-row, RunResult, transaction ordering — is testable offline.
+export function libsqlJuneDb(client: LibsqlClientLike): JuneDb {
+  const self: JuneDb = {
+    dialect: "sqlite", // libsql IS sqlite — same SQL + Juno tables as sqlite()/d1()
+    async query<T>(sql: string, params: unknown[] = []) {
+      return (await client.execute({ sql, args: params })).rows as T[];
+    },
+    async get<T>(sql: string, params: unknown[] = []) {
+      return ((await client.execute({ sql, args: params })).rows[0] ?? undefined) as T | undefined;
+    },
+    async run(sql: string, params: unknown[] = []): Promise<RunResult> {
+      const r = await client.execute({ sql, args: params });
+      // libsql returns lastInsertRowid as a bigint; RunResult is number-ish.
+      return { changes: r.rowsAffected ?? 0, lastInsertRowid: Number(r.lastInsertRowid ?? 0) };
+    },
+    async exec(sql: string) {
+      // DDL / migrations are multi-statement; executeMultiple splits on `;`.
+      if (client.executeMultiple) await client.executeMultiple(sql);
+      else await client.execute(sql);
+    },
+    async transaction<T>(fn: (tx: JuneDb) => Promise<T>) {
+      // Test/dev grade, matching postgres()/mysql(): BEGIN/COMMIT on the one
+      // client. (For strict isolation over HTTP, libsql's interactive
+      // client.transaction() is the upgrade path.)
+      await client.execute("BEGIN");
+      try {
+        const out = await fn(self);
+        await client.execute("COMMIT");
+        return out;
+      } catch (e) {
+        await client.execute("ROLLBACK");
+        throw e;
+      }
+    },
+    async close() {
+      await client.close();
+    },
+  };
+  return self;
+}
+
+// `turso({ url, authToken })` — declared in june.config.ts, or omit both to read
+// the standard TURSO_DATABASE_URL / TURSO_AUTH_TOKEN env vars at open() time
+// (NOT at construction — so the build can evaluate the config without the secrets
+// present, and the deployed function reads them from its own environment).
+export function turso(opts: { url?: string; authToken?: string } = {}): DbFactory {
+  return {
+    kind: "turso",
+    open: async () => {
+      const url = opts.url ?? readEnv("TURSO_DATABASE_URL");
+      const authToken = opts.authToken ?? readEnv("TURSO_AUTH_TOKEN");
+      if (!url) {
+        throw new Error(
+          "turso(): no database url — pass { url } or set TURSO_DATABASE_URL in the environment.",
+        );
+      }
+      // The pure-fetch web client: works in dev (Bun) AND bundles into the one
+      // deployed function (the node client would pull native bindings). Turso is
+      // remote (libsql:// over HTTPS), which is exactly what the web client speaks.
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const mod = (await import("@libsql/client/web")) as any;
+      const createClient = (mod.default ?? mod).createClient;
+      return libsqlJuneDb(createClient({ url, authToken }));
+    },
+  };
+}
+
+function readEnv(name: string): string | undefined {
+  return typeof process !== "undefined" && process.env ? process.env[name] : undefined;
+}