serveDeno

serveDeno(app, options) starts Deno.serve for a createServerApp application: it handles HTTP through app.fetch, upgrades Socket channels through Deno.upgradeWebSocket and records each connection's IP (remoteAddr). With handleSignals, it shuts down gracefully on SIGINT and SIGTERM (SIGINT and SIGBREAK on Windows) and, since 1.3, applies processErrors.

It is what the meeko build --adapter deno output runs (.meeko/output/deno/main.js).

Usage#

import { createServerApp } from "@meekojs/meeko/server";
import { createDenoAssetReader, serveDeno } from "@meekojs/meeko/deno";

const app = await createServerApp({
  manifest, load, runtime, production: true,
  assets: createDenoAssetReader({ root: new URL("./client/", import.meta.url), assets: manifest.assets ?? {} }),
});
const server = await serveDeno(app, { host: "0.0.0.0", port: 8000, handleSignals: true });
console.log(server.url);

Type#

function serveDeno(app: ServerApp, options?: ServeDenoOptions): Promise<DenoServer>

interface ServeDenoOptions {
	readonly host?: string
	readonly port?: number
	readonly publicOrigin?: string
	readonly platform?: ServerPlatform
	readonly onError?: (error: unknown, requestId: string) => void
	readonly maxMessageBytes?: number
	readonly idleTimeout?: number
	readonly handleSignals?: boolean
}

interface DenoServer {
	readonly url: string
	readonly finished: Promise<void>
	close(): Promise<void>
}

Parameters#

serveDeno(app, options?):

Return value#

A promise with a DenoServer:

Examples#

Build and run with minimum permissions#

npx meeko build --adapter deno
deno run --allow-net --allow-env --allow-read=.meeko/output/deno .meeko/output/deno/main.js

main.js includes all server dependencies. --allow-env is required because the runtime receives Deno.env.toObject(); meeko preview --adapter deno grants -A.

A container#

FROM denoland/deno:2.9.8
WORKDIR /app
COPY .meeko/output/deno ./
ENV MEEKO_HOST=0.0.0.0 MEEKO_PORT=8000 MEEKO_PUBLIC_ORIGIN=https://tienda.example.com
EXPOSE 8000
CMD ["run", "--allow-net", "--allow-env", "--allow-read=.", "main.js"]

server.host and server.port from meeko.config.ts only apply to Node; here, use MEEKO_HOST and MEEKO_PORT (or PORT).

Tests with a free port#

const server = await serveDeno(app, { port: 0 });
const response = await fetch(`${server.url}/api/health`);
await response.body?.cancel();
await server.close();
await server.finished;

Common mistakes#

Run the output without permissions#

deno run .meeko/output/deno/main.js

Deno requests network, environment and build read access (or denies it if there is no terminal), and startup fails without those permissions.

deno run --allow-net --allow-env --allow-read=.meeko/output/deno .meeko/output/deno/main.js

Call it outside Deno#

// node server.mjs
await serveDeno(app);

Error: The Meeko Deno adapter requires the Deno runtime.

deno run --allow-net --allow-env --allow-read=. main.js

An invalid port or limit#

await serveDeno(app, { port: 70000, maxMessageBytes: 0 });

RangeError: Invalid port: 70000; with a valid port, RangeError: Invalid maxMessageBytes (or Invalid idleTimeout).

await serveDeno(app, { port: 8000, maxMessageBytes: 16 * 1024 });

Notes#

• Socket in Deno. Deno.upgradeWebSocket has no frame limit: the adapter measures each message and closes larger ones with 1009, but Deno has already reassembled it in memory. Limit request sizes at the proxy if you need an earlier cap. Binary messages close with 1003; the outgoing buffer is controlled with bufferedAmount.
• Session rejections. The upgrade completes and the connection closes with 4401 or 4403 one loop iteration after opening, so the close reaches the client even if it has already sent a message.
• Process failures. Deno uses globalThis's unhandledrejection and error; it preserves requestId in rejections.
• IP. The connection's remoteAddr; behind a proxy, MEEKO_TRUST_PROXY. An invalid variable stops startup.
• CSP and headers (since 1.7). server.contentSecurityPolicy and server.headers apply just as in Node.

Related#

• createDenoAssetReaderStreams only build files listed in the asset manifest using Deno.open, with ETag, HEAD, 304 and Meeko's cache policy.
• handleProcessErrorsApplies server/runtime.ts processErrors policy to a custom host for unhandled rejections and uncaught exceptions outside a request.
• createServerAppCreates the portable server application (pages, API, RPC, Socket, assets, sessions and middleware) from the build manifest and a module loader.
• serveNodeServes a Meeko application with Node's HTTP server, its Socket channels with ws, graceful shutdown on signals and the process failure policy.
• serverThe meeko build adapter (node, bun, deno, cloudflare or static) and its options, plus, since 1.7, response CSP and headers for server adapters.
• DenoMeeko as a full-stack framework
• Adapter conformanceMeeko as a full-stack framework