add unix socket option

Author: lilnasy

package/package.json

@@ -20,12 +20,12 @@
   "type": "module",
   "exports": {
     ".": {
-      "default": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
     },
     "./server.js": {
-      "default": "./dist/server.js",
-      "types": "./dist/server.d.ts"
+      "types": "./dist/server.d.ts",
+      "default": "./dist/server.js"
     },
     "./package.json": "./package.json"
   },

package/src/index.ts

@@ -1,14 +1,11 @@
-import { defineIntegration } from 'astro-integration-kit';
-
 import { name as packageName } from '~/package.json';
 import { CreateExportsEnum } from '~/types.ts';
-import { OptionsSchema } from '~/validators';
 
-import type { AstroAdapter } from 'astro';
+import type { AstroAdapter, AstroIntegration } from 'astro';
 
-import type { Options } from '~/types.ts';
+import type { Options, InternalOptions } from '~/types.ts';
 
-export function getAdapter(args: Options = {}): AstroAdapter {
+export function getAdapter(args: InternalOptions): AstroAdapter {
   return {
     args,
     exports: [
@@ -30,23 +27,31 @@ export function getAdapter(args: Options = {}): AstroAdapter {
   };
 }
 
-export default defineIntegration({
-  name: packageName,
-  optionsSchema: OptionsSchema.optional(),
-  setup: (integration) => ({
+export default (options?: Options): AstroIntegration => {
+  if (options) {
+    if (options.cluster && typeof options.cluster !== "boolean") {
+      throw new Error(`[${packageName}] options.cluster must be a boolean, but the adapter was provided with ${options.cluster} instead.`)
+    }
+    if (options.unix && typeof options.unix !== "string") {
+      throw new Error(`[${packageName}] options.unix must be a string, but the adapter was provided with ${options.unix} instead.`)
+    }
+  }
+  return {
+    name: packageName,
     hooks: {
-      'astro:config:done': (params) => {
+      'astro:config:done': params => {
         params.setAdapter(
           getAdapter({
-            ...integration.options,
+            cluster: options?.cluster,
+            unix: options?.unix,
             assets: params.config.build.assets,
-            client: params.config.build.client?.toString(),
+            client: params.config.build.client.toString(),
             host: params.config.server.host,
             port: params.config.server.port,
-            server: params.config.build.server?.toString(),
+            server: params.config.build.server.toString(),
           }),
         );
       },
     },
-  }),
-});
+  }
+}

package/src/server/index.ts

@@ -10,9 +10,9 @@ import { extractHostname, serveStaticFile } from '~/server/utils.ts';
 import type { SSRManifest } from 'astro';
 import type { Server } from 'bun';
 
-import type { CreateExports, Options } from '~/types.ts';
+import type { CreateExports, InternalOptions } from '~/types.ts';
 
-export function createExports(manifest: SSRManifest, options: Options): CreateExports {
+export function createExports(manifest: SSRManifest, options: InternalOptions): CreateExports {
   return {
     handle: handler(manifest, options),
     running: () => _server !== null,
@@ -26,9 +26,10 @@ export function createExports(manifest: SSRManifest, options: Options): CreateEx
 }
 
 let _server: Server | null = null;
-export function start(manifest: SSRManifest, options: Options): void {
+export function start(manifest: SSRManifest, options: InternalOptions): void {
   const hostname = process.env.HOST ?? extractHostname(options.host);
   const port = process.env.PORT ? Number.parseInt(process.env.PORT) : options.port;
+  const unix = process.env.UNIX ?? options.unix
 
   if (cluster.isPrimary && options.cluster) {
     const numCPUs = os.cpus().length;
@@ -43,16 +44,27 @@ export function start(manifest: SSRManifest, options: Options): void {
     const app = new App(manifest);
     const logger = app.getAdapterLogger();
 
-    _server = Bun.serve({
-      development: import.meta.env.DEV,
-      error: (error) =>
-        new Response(`<pre>${error}\n${error.stack}</pre>`, {
-          headers: { 'Content-Type': 'text/html' },
-        }),
-      fetch: handler(manifest, options),
-      hostname,
-      port,
-    });
+    if (unix) {
+      _server = Bun.serve({
+        error: (error) =>
+          new Response(`<pre>${error}\n${error.stack}</pre>`, {
+            headers: { 'Content-Type': 'text/html' },
+          }),
+        fetch: handler(manifest, options),
+        unix,
+      });
+    }
+    else {
+      _server = Bun.serve({
+        error: (error) =>
+          new Response(`<pre>${error}\n${error.stack}</pre>`, {
+            headers: { 'Content-Type': 'text/html' },
+          }),
+        fetch: handler(manifest, options),
+        hostname,
+        port,
+      });
+    }
 
     function exit(): void {
       if (_server) _server.stop();
@@ -69,7 +81,7 @@ export function start(manifest: SSRManifest, options: Options): void {
 
 function handler(
   manifest: SSRManifest,
-  options: Options,
+  options: InternalOptions,
 ): (req: Request, server: Server) => Promise<Response> {
   const clientRoot = options.client ?? new URL('../client/', import.meta.url).href;
 

package/src/types.ts

@@ -1,7 +1,85 @@
 import type { Server } from 'bun';
-import type { z } from 'zod';
+import type { AstroConfig } from 'astro';
+
+// the options available to the user when they are adding
+// the adapter to their configuration
+export interface Options {
+  /**
+   * Create a cluster of bun servers listening on the same port,
+   * and automatically load-balance incoming requests across them.
+   * 
+   * Example:
+   * ```ts
+   * export default defineConfig({
+   *   adapter: bun({ cluster: true })
+   * })
+   * ```
+   * 
+   * Defaults to `false`
+   */
+  cluster?: boolean
+  /**
+   * The path to the unix socket on which to host the server.
+   * 
+   * This can provide better performance when Bun is running alongside
+   * a local reverse proxy that supports unix sockets.
+   * 
+   * When a unix socket is provided, Bun does not bind to a TCP port,
+   * and the options and environment variables for the hostname and port
+   * are ignored.
+   * 
+   * Example:
+   * ```ts
+   * export default defineConfig({
+   *   adapter: bun({ unix: "/tmp/my-socket.sock" })
+   * })
+   * ```
+   */
+  unix?: string
+}
+
+// options provided by the user combined with other
+// relevant configuration picked from the integration API
+export interface InternalOptions extends Options {
+  /**
+   * Name of the publicly exposed directory where all
+   * static assets are put.
+   * 
+   * Astro defaults to `"_astro"`.
+   */
+  assets: AstroConfig["build"]["assets"],
+  /**
+   * The full file URL to where astro is configured to put
+   * the client bundle and assets such as images, fonts,
+   * stylesheets, and static html.
+   * 
+   * Astro defaults to `"<project root>/dist/client/"`.
+   */
+  client: AstroConfig["build"]["server"]["href"],
+  /**
+   * The full file URL to where astro is configured to put
+   * the server bundle.
+   * 
+   * Astro defaults to `"<project root>/dist/server/""`.
+   */
+  server: AstroConfig["build"]["server"]["href"],
+  /**
+   * Network address where the astro dev server is
+   * configured to listen for requests in addition to
+   * `localhost`.
+   * 
+   * Astro defaults to `false`.
+   */
+  host: AstroConfig["server"]["host"],
+  /**
+   * Network port where the astro dev server is
+   * configured to listen for requests.
+   * 
+   * Astro default to `4321`.
+   */
+  port: AstroConfig["server"]["port"],
+}
 
-import type { OptionsSchema } from '~/validators';
 
 export enum CreateExportsEnum {
   HANDLE = 'handle',
@@ -16,5 +94,3 @@ export type CreateExports = {
   [CreateExportsEnum.START]: () => void;
   [CreateExportsEnum.STOP]: () => void;
 };
-
-export type Options = z.infer<typeof OptionsSchema>;