pike/glyph Public Public: anyone can read this; nobody can change it.

/**

 * The process the forge runs. `serve` opens the database and listens:

 * every request gets the floor (`http.ts`), an identity (`who.ts`), the

 * door (`security.ts`) and one route (`routes.ts`) — so a request from

 * another site, from someone going too fast, or from someone the contract

 * turns away is refused before a byte of it is read. Run directly, it

 * serves what the forge said; a test calls `serve` with its own.

 */

import { openDb } from "./db.ts";

import { dataDir, identityKey, title, where } from "./env.ts";

import { html, text } from "./http.ts";

import { serveSpan } from "./otel.ts";

import { match } from "./routes.ts";

import { door } from "./security.ts";

import { who } from "./who.ts";

export interface ServeOptions {

  readonly port: number;

  readonly hostname?: string | undefined;

  readonly dataDir: string;

  readonly identityKey: string;

}

export function serve(options: ServeOptions) {

  const db = openDb(options.dataDir);

  return Bun.serve({

    port: options.port,

    hostname: options.hostname ?? "127.0.0.1",

    // A connection that says nothing for a minute is dropped. The event

    // stream heartbeats every 25 seconds to stay well inside that.

    idleTimeout: 60,

    // Every request is a span (src/otel.ts), a child of the forge's: it

    // shows in the platform's traces with its route, status and timing.

    // Wrap slow work in `span("name", () => ...)` to see it there too.

    fetch: (request, server) =>

      serveSpan(request, async (span) => {

        const url = new URL(request.url);

        const me = who(request, options.identityKey);

        const refused = door(

          db,

          request,

          url,

          me,

          server.requestIP(request)?.address ?? "?",

        );

        if (refused !== undefined) return head(request, refused);

        const found = match(

          request.method === "HEAD" ? "GET" : request.method,

          url.pathname,

        );

        if (found === undefined) return text("not found", 404);

        span.set("http.route", found.route.path);

        const response = await found.route.handle({

          request,

          url,

          db,

          who: me,

          params: found.params,

        });

        return head(request, response);

      }),

    // A bug answers with the floor and nothing else: never the runtime's

    // own error page, which carries source and paths, and never without

    // the headers. The detail goes to the log, where it belongs.

    error(error) {

      // Inside the generated app, which has no forge log module.

      console.error(error);

      return html("<h1>Something went wrong</h1>", 500);

    },

  });

}

// HEAD is GET without the body: a health check sees the app up.

const head = (request: Request, response: Response): Response =>

  request.method === "HEAD"

    ? new Response(null, { status: response.status, headers: response.headers })

    : response;

if (import.meta.main) {

  const server = serve({

    port: Number(process.env.PORT ?? 8080),

    hostname: process.env.HOST,

    dataDir,

    identityKey,

  });

  console.log(

    `${title} listening on http://${server.hostname}:${server.port} (${where})`,

  );

}