@quilted/rollup 0.2.13 → 0.2.14

package/source/app.ts

@@ -36,6 +36,9 @@ import {
   type BrowserGroupTargetSelection,
 } from './shared/browserslist.ts';
 import {Project} from './shared/project.ts';
+import type {ServerRuntime} from './shared/server.ts';
+
+import type {NodeServerRuntimeOptions} from './server.ts';
 
 export interface AppBaseOptions {
   /**
@@ -91,6 +94,11 @@ export interface AppOptions extends AppBaseOptions {
    */
   server?: Omit<AppServerOptions, keyof AppBaseOptions> &
     Pick<AppServerOptions, 'env'>;
+
+  /**
+   * Customizations to the application for the runtime it will execute in.
+   */
+  runtime?: AppRuntime;
 }
 
 export interface AppBrowserOptions extends AppBaseOptions {
@@ -114,6 +122,11 @@ export interface AppBrowserOptions extends AppBaseOptions {
    * Customizes the assets created for your application.
    */
   assets?: AppBrowserAssetsOptions;
+
+  /**
+   * Customizations to the application for the runtime it will execute in.
+   */
+  runtime?: Omit<AppRuntime, 'server'>;
 }
 
 export interface AppBrowserModuleOptions {
@@ -140,6 +153,7 @@ export interface AppBrowserAssetsOptions {
    */
   minify?: boolean;
 
+  directory?: string;
   baseURL?: string;
   targets?: BrowserGroupTargetSelection;
   priority?: number;
@@ -193,6 +207,11 @@ export interface AppServerOptions extends AppBaseOptions {
    * Customizes the output files created for your server.
    */
   output?: AppServerOutputOptions;
+
+  /**
+   * Customizations to the server for the runtime it will execute in.
+   */
+  runtime?: AppServerRuntime;
 }
 
 export interface AppServerOutputOptions
@@ -214,13 +233,29 @@ export interface AppServerOutputOptions
    * @default 'async-only'
    */
   hash?: boolean | 'async-only';
+}
 
+export interface AppRuntime {
   /**
-   * What module format to use for the server output.
-   *
-   * @default 'esmodules'
+   * Overrides to the assets for this application.
+   */
+  assets?: {
+    /**
+     * The directory to output the application’s assets into.
+     */
+    directory?: string;
+  };
+
+  /**
+   * Customizations to the server for this runtime.
    */
-  format?: 'esmodules' | 'esm' | 'es' | 'commonjs' | 'cjs';
+  server?: AppServerRuntime;
+}
+
+export interface AppServerRuntime extends Omit<ServerRuntime, 'requestRouter'> {
+  requestRouter?(options: {
+    assets: Required<Pick<AppBrowserAssetsOptions, 'baseURL'>>;
+  }): string;
 }
 
 export {
@@ -232,7 +267,7 @@ export {
 
 const require = createRequire(import.meta.url);
 
-export async function quiltAppOptions({
+export async function quiltApp({
   root = process.cwd(),
   app,
   env,
@@ -240,6 +275,7 @@ export async function quiltAppOptions({
   assets,
   browser: browserOptions,
   server: serverOptions,
+  runtime,
 }: AppOptions = {}) {
   const project = Project.load(root);
 
@@ -251,10 +287,11 @@ export async function quiltAppOptions({
 
   browserGroupEntries.forEach(([name, browsers], index) => {
     optionPromises.push(
-      quiltAppBrowserOptions({
+      quiltAppBrowser({
         root: project.root,
         app,
         graphql,
+        runtime,
         ...browserOptions,
         env: {
           ...resolveEnvOption(env),
@@ -274,10 +311,11 @@ export async function quiltAppOptions({
   });
 
   optionPromises.push(
-    quiltAppServerOptions({
+    quiltAppServer({
       root: project.root,
       app,
       graphql,
+      runtime: runtime?.server,
       ...serverOptions,
       env: {
         ...resolveEnvOption(env),
@@ -290,12 +328,12 @@ export async function quiltAppOptions({
   return Promise.all(optionPromises);
 }
 
-export async function quiltAppBrowserOptions(options: AppBrowserOptions = {}) {
-  const {root = process.cwd(), assets} = options;
+export async function quiltAppBrowser(options: AppBrowserOptions = {}) {
+  const {root = process.cwd(), assets, runtime} = options;
   const project = Project.load(root);
 
   const [plugins, browserGroup] = await Promise.all([
-    quiltAppBrowser(options),
+    quiltAppBrowserPlugins(options),
     getBrowserGroupTargetDetails(assets?.targets, {
       root: project.root,
     }),
@@ -311,7 +349,9 @@ export async function quiltAppBrowserOptions(options: AppBrowserOptions = {}) {
     plugins,
     output: {
       format: isESM ? 'esm' : 'systemjs',
-      dir: project.resolve(`build/assets`),
+      dir: project.resolve(
+        assets?.directory ?? runtime?.assets?.directory ?? `build/assets`,
+      ),
       entryFileNames: `[name]${targetFilenamePart}.[hash].js`,
       assetFileNames: `[name]${targetFilenamePart}.[hash].[ext]`,
       chunkFileNames: `[name]${targetFilenamePart}.[hash].js`,
@@ -322,7 +362,7 @@ export async function quiltAppBrowserOptions(options: AppBrowserOptions = {}) {
   } satisfies RollupOptions;
 }
 
-export async function quiltAppBrowser({
+export async function quiltAppBrowserPlugins({
   root = process.cwd(),
   app,
   entry,
@@ -510,20 +550,22 @@ export function quiltAppBrowserInput({
   } satisfies Plugin;
 }
 
-export async function quiltAppServerOptions(options: AppServerOptions = {}) {
-  const {root = process.cwd(), output} = options;
+export async function quiltAppServer(options: AppServerOptions = {}) {
+  const {
+    output,
+    root = process.cwd(),
+    runtime = nodeAppServerRuntime(),
+  } = options;
 
   const project = Project.load(root);
   const hash = output?.hash ?? 'async-only';
-  const outputFormat = output?.format ?? 'esmodules';
 
-  const plugins = await quiltAppServer(options);
+  const plugins = await quiltAppServerPlugins({...options, root, runtime});
 
   return {
     plugins,
     output: {
-      format:
-        outputFormat === 'commonjs' || outputFormat === 'cjs' ? 'cjs' : 'esm',
+      format: 'esm',
       dir: project.resolve(`build/server`),
       entryFileNames: `[name]${hash === true ? `.[hash]` : ''}.js`,
       chunkFileNames: `[name]${
@@ -531,11 +573,12 @@ export async function quiltAppServerOptions(options: AppServerOptions = {}) {
       }.js`,
       assetFileNames: `[name]${hash === true ? `.[hash]` : ''}.[ext]`,
       generatedCode: 'es2015',
+      ...runtime.output?.options,
     },
   } satisfies RollupOptions;
 }
 
-export async function quiltAppServer({
+export async function quiltAppServerPlugins({
   root = process.cwd(),
   app,
   env,
@@ -544,6 +587,7 @@ export async function quiltAppServer({
   graphql = true,
   assets,
   output,
+  runtime,
 }: AppServerOptions = {}) {
   const project = Project.load(root);
   const mode = (typeof env === 'object' ? env?.mode : env) ?? 'production';
@@ -584,10 +628,20 @@ export async function quiltAppServer({
     quiltAppServerInput({root: project.root, entry, format}),
     ...nodePlugins,
     replaceProcessEnv({mode}),
-    magicModuleEnv({...resolveEnvOption(env), mode}),
+    magicModuleEnv({runtime: runtime?.env, ...resolveEnvOption(env), mode}),
     magicModuleAppComponent({entry: app, root: project.root}),
-    magicModuleAppServerEntry({
-      assets: {baseURL},
+    createMagicModulePlugin({
+      name: '@quilted/request-router',
+      sideEffects: true,
+      module: MAGIC_MODULE_ENTRY,
+      source() {
+        const options = {assets: {baseURL}};
+
+        return (
+          runtime?.requestRouter?.(options) ??
+          nodeAppServerRuntime().requestRouter(options)
+        );
+      },
     }),
     magicModuleAppRequestRouter({entry, root: project.root}),
     magicModuleAppAssetManifests(),
@@ -694,6 +748,82 @@ export function quiltAppServerInput({
   } satisfies Plugin;
 }
 
+export interface NodeAppServerRuntimeOptions extends NodeServerRuntimeOptions {
+  /**
+   * Whether the server should serve assets from the asset output directory.
+   *
+   * @default true
+   */
+  assets?: boolean;
+}
+
+export function nodeAppServerRuntime({
+  host,
+  port,
+  format = 'module',
+  assets: serveAssets = true,
+}: NodeAppServerRuntimeOptions = {}) {
+  const rollupFormat =
+    format === 'commonjs' || format === 'cjs' ? 'cjs' : 'esm';
+
+  return {
+    env: 'process.env',
+    output: {
+      options: {
+        format: rollupFormat,
+      },
+    },
+    requestRouter({assets}) {
+      const {baseURL} = assets;
+
+      return multiline`
+        ${serveAssets ? `import * as path from 'path';` : ''}
+        ${rollupFormat === 'cjs' ? '' : `import {fileURLToPath} from 'url';`}
+        import {createServer} from 'http';
+
+        import requestRouter from ${JSON.stringify(
+          MAGIC_MODULE_REQUEST_ROUTER,
+        )};
+
+        import {createHttpRequestListener${
+          serveAssets ? ', serveStatic' : ''
+        }} from '@quilted/quilt/request-router/node';
+
+        const port = ${port ?? 'Number.parseInt(process.env.PORT, 10)'};
+        const host = ${host ? JSON.stringify(host) : 'process.env.HOST'};
+
+        ${
+          serveAssets
+            ? multiline`
+              const dirname = ${
+                rollupFormat === 'cjs'
+                  ? `__dirname`
+                  : `path.dirname(fileURLToPath(import.meta.url))`
+              };
+              const serve = serveStatic(path.resolve(dirname, '../assets'), {
+                baseUrl: ${JSON.stringify(baseURL)},
+              });
+            `
+            : ''
+        }
+        const listener = createHttpRequestListener(requestRouter);
+      
+        createServer(async (request, response) => {
+          ${
+            serveAssets
+              ? `if (request.url.startsWith(${JSON.stringify(
+                  baseURL,
+                )})) return serve(request, response);`
+              : ''
+          }
+
+          await listener(request, response);
+        }).listen(port, host);
+      `;
+    },
+  } satisfies AppServerRuntime;
+}
+
 export function magicModuleAppComponent({
   entry,
   root = process.cwd(),
@@ -818,75 +948,6 @@ export function magicModuleAppBrowserEntry({
   });
 }
 
-export function magicModuleAppServerEntry({
-  host,
-  port,
-  assets,
-  format = 'module',
-}: {
-  host?: string;
-  port?: number;
-  assets?: boolean | {baseURL: string};
-  format?: 'module' | 'commonjs';
-} = {}) {
-  const baseURL = typeof assets === 'object' ? assets.baseURL : '/assets/';
-
-  return createMagicModulePlugin({
-    name: '@quilted/request-router/app-server',
-    module: MAGIC_MODULE_ENTRY,
-    sideEffects: true,
-    async source() {
-      const serveAssets = Boolean(assets);
-
-      return multiline`
-        ${serveAssets ? `import * as path from 'path';` : ''}
-        ${
-          serveAssets && format === 'module'
-            ? `import {fileURLToPath} from 'url';`
-            : ''
-        }
-        import {createServer} from 'http';
-
-        import requestRouter from ${JSON.stringify(
-          MAGIC_MODULE_REQUEST_ROUTER,
-        )};
-
-        import {createHttpRequestListener${
-          serveAssets ? ', serveStatic' : ''
-        }} from '@quilted/quilt/request-router/node';
-
-        const port = ${port ?? 'Number.parseInt(process.env.PORT, 10)'};
-        const host = ${host ? JSON.stringify(host) : 'process.env.HOST'};
-
-        ${
-          serveAssets
-            ? `const dirname = ${
-                format === 'module'
-                  ? 'path.dirname(fileURLToPath(import.meta.url))'
-                  : '__dirname'
-              };\nconst serve = serveStatic(path.resolve(dirname, '../assets'), {
-                baseUrl: ${JSON.stringify(baseURL)},
-              });`
-            : ''
-        }
-        const listener = createHttpRequestListener(requestRouter);
-      
-        createServer(async (request, response) => {
-          ${
-            serveAssets
-              ? `if (request.url.startsWith(${JSON.stringify(
-                  baseURL,
-                )})) return serve(request, response);`
-              : ''
-          }
-
-          await listener(request, response);
-        }).listen(port, host);
-      `;
-    },
-  });
-}
-
 export function magicModuleAppAssetManifests() {
   return createMagicModulePlugin({
     name: '@quilted/magic-module/asset-manifests',

package/source/index.ts

@@ -1,13 +1,15 @@
 export {
-  quiltAppOptions,
+  quiltApp,
   quiltAppBrowser,
-  quiltAppBrowserOptions,
+  quiltAppBrowserPlugins,
   quiltAppServer,
-  quiltAppServerOptions,
+  quiltAppServerPlugins,
   type AppOptions,
   type AppBaseOptions,
   type AppBrowserOptions,
   type AppServerOptions,
+  type AppRuntime,
+  type AppServerRuntime,
 } from './app.ts';
 export {quiltModule, type ModuleOptions} from './module.ts';
 export {
@@ -16,4 +18,11 @@ export {
   quiltPackageESNext,
   type PackageOptions,
 } from './package.ts';
-export {quiltServer, type ServerOptions} from './server.ts';
+export {
+  quiltServer,
+  type ServerOptions,
+  type ServerOutputOptions,
+  type ServerRuntime,
+} from './server.ts';
+export {multiline} from './shared/strings.ts';
+export * from './constants.ts';

package/source/server.ts

@@ -7,10 +7,11 @@ import {
   removeBuildFiles,
 } from './shared/rollup.ts';
 
-import {magicModuleRequestRouterEntry} from './features/request-router.ts';
+import {multiline} from './shared/strings.ts';
 import {resolveEnvOption, type MagicModuleEnvOptions} from './features/env.ts';
 import {MAGIC_MODULE_ENTRY, MAGIC_MODULE_REQUEST_ROUTER} from './constants.ts';
 import {createMagicModulePlugin} from './shared/magic-module.ts';
+import type {ServerRuntime} from './shared/server.ts';
 
 export interface ServerOptions {
   /**
@@ -60,25 +61,20 @@ export interface ServerOptions {
   output?: ServerOutputOptions;
 
   /**
-   * The port that the server will listen on when it runs. This only applies
-   * when you use the `request-router` format — if you use the `custom` format,
-   * you are responsible for starting the server yourself.
-   *
-   * If you do not provide a value here, the server will listen for requests on
-   * the port specified by `process.env.NODE_ENV`.
-   */
-  port?: number | string;
-
-  /**
-   * The host that the server will listen on when it runs. This only applies
-   * when you use the `request-router` format — if you use the `custom` format,
-   * you are responsible for starting the server yourself.
+   * Customizations to the server for the runtime it will execute in.
    */
-  host?: string;
+  runtime?: ServerRuntime;
 }
 
 export interface ServerOutputOptions
   extends Pick<RollupNodePluginOptions, 'bundle'> {
+  /**
+   * The directory to output the server into.
+   *
+   * @default 'build/server'
+   */
+  directory?: string;
+
   /**
    * Whether to minify assets created for this server.
    *
@@ -96,15 +92,9 @@ export interface ServerOutputOptions
    * @default 'async-only'
    */
   hash?: boolean | 'async-only';
-
-  /**
-   * What module format to use for the server output.
-   *
-   * @default 'esmodules'
-   */
-  format?: 'esmodules' | 'esm' | 'es' | 'commonjs' | 'cjs';
 }
 
+export type {ServerRuntime};
 export {MAGIC_MODULE_ENTRY, MAGIC_MODULE_REQUEST_ROUTER};
 
 export async function quiltServer({
@@ -114,18 +104,18 @@ export async function quiltServer({
   env,
   graphql = true,
   output,
-  port,
-  host,
+  runtime = nodeServerRuntime(),
 }: ServerOptions = {}) {
   const project = Project.load(rootPath);
   const mode =
     (typeof env === 'object' ? env?.mode : undefined) ?? 'production';
-  const outputDirectory = project.resolve('build/server');
+  const outputDirectory = project.resolve(
+    output?.directory ?? runtime.output?.directory ?? 'build/server',
+  );
 
   const minify = output?.minify ?? false;
   const bundle = output?.bundle;
   const hash = output?.hash ?? 'async-only';
-  const outputFormat = output?.format ?? 'esmodules';
 
   const [
     {visualizer},
@@ -159,7 +149,7 @@ export async function quiltServer({
   const plugins: InputPluginOption[] = [
     ...nodePlugins,
     replaceProcessEnv({mode}),
-    magicModuleEnv({...resolveEnvOption(env), mode}),
+    magicModuleEnv({runtime: runtime.env, ...resolveEnvOption(env), mode}),
     sourceCode({mode, targets: ['current node']}),
     tsconfigAliases({root: project.root}),
     monorepoPackageAliases({root: project.root}),
@@ -175,9 +165,15 @@ export async function quiltServer({
         module: MAGIC_MODULE_REQUEST_ROUTER,
         alias: serverEntry,
       }),
-      magicModuleRequestRouterEntry({
-        host,
-        port: typeof port === 'string' ? Number.parseInt(port, 10) : port,
+      createMagicModulePlugin({
+        name: '@quilted/request-router',
+        sideEffects: true,
+        module: MAGIC_MODULE_ENTRY,
+        source() {
+          return (
+            runtime.requestRouter?.() ?? nodeServerRuntime().requestRouter()
+          );
+        },
       }),
     );
   }
@@ -206,8 +202,7 @@ export async function quiltServer({
       finalEntry === MAGIC_MODULE_ENTRY ? {server: finalEntry} : finalEntry,
     plugins,
     output: {
-      format:
-        outputFormat === 'commonjs' || outputFormat === 'cjs' ? 'cjs' : 'esm',
+      format: 'esm',
       dir: outputDirectory,
       entryFileNames: `[name]${hash === true ? `.[hash]` : ''}.js`,
       chunkFileNames: `[name]${
@@ -215,10 +210,71 @@ export async function quiltServer({
       }.js`,
       assetFileNames: `[name]${hash === true ? `.[hash]` : ''}.[ext]`,
       generatedCode: 'es2015',
+      ...runtime.output?.options,
     },
   } satisfies RollupOptions;
 }
 
+export interface NodeServerRuntimeOptions {
+  /**
+   * The port that the server will listen on when it runs. This only applies
+   * when you use the `request-router` format — if you use the `custom` format,
+   * you are responsible for starting the server yourself.
+   *
+   * If you do not provide a value here, the server will listen for requests on
+   * the port specified by `process.env.NODE_ENV`.
+   */
+  port?: number | string;
+
+  /**
+   * The host that the server will listen on when it runs.
+   */
+  host?: string;
+
+  /**
+   * What module format to use for the server output.
+   *
+   * @default 'module'
+   */
+  format?:
+    | 'module'
+    | 'modules'
+    | 'esmodules'
+    | 'esm'
+    | 'es'
+    | 'commonjs'
+    | 'cjs';
+}
+
+export function nodeServerRuntime({
+  host,
+  port,
+  format = 'module',
+}: NodeServerRuntimeOptions = {}) {
+  return {
+    env: 'process.env',
+    output: {
+      options: {
+        format: format === 'commonjs' || format === 'cjs' ? 'cjs' : 'esm',
+      },
+    },
+    requestRouter() {
+      return multiline`
+        import requestRouter from ${JSON.stringify(
+          MAGIC_MODULE_REQUEST_ROUTER,
+        )};
+
+        import {createHttpServer} from '@quilted/quilt/request-router/node';
+
+        const port = ${port ?? 'Number.parseInt(process.env.PORT, 10)'};
+        const host = ${host ? JSON.stringify(host) : 'process.env.HOST'};
+      
+        createHttpServer(requestRouter).listen(port, host);
+      `;
+    },
+  } satisfies ServerRuntime;
+}
+
 async function sourceForServer(project: Project) {
   const {main, exports} = project.packageJSON.raw;
 

package/source/shared/server.ts

@@ -0,0 +1,46 @@
+import type {OutputOptions} from 'rollup';
+
+export interface ServerRuntime {
+  /**
+   * A string that will be inlined directly as code to reference a runtime constant
+   * that contains environment variables.
+   */
+  env?: string;
+
+  /**
+   * Overrides to the output options for this server.
+   */
+  output?: {
+    /**
+     * What module format to use for the server output.
+     *
+     * @default 'module'
+     */
+    format?:
+      | 'module'
+      | 'modules'
+      | 'esmodules'
+      | 'esm'
+      | 'es'
+      | 'commonjs'
+      | 'cjs';
+
+    /**
+     * The directory to output the server to.
+     */
+    directory?: string;
+
+    /**
+     * Overrides to the Rollup output options.
+     */
+    options?: OutputOptions;
+  };
+
+  /**
+   * The content to use as the entry point when the server uses the `request-router`
+   * format for their server. This file should import the request router instance for
+   * this app from 'quilt:module/request-router', and create a server that is appropriate
+   * for this runtime.
+   */
+  requestRouter?(): string;
+}

package/build/esm/features/request-router.mjs

@@ -1,31 +0,0 @@
-import { MAGIC_MODULE_ENTRY, MAGIC_MODULE_REQUEST_ROUTER } from '../constants.mjs';
-import { createMagicModulePlugin } from '../shared/magic-module.mjs';
-import { multiline } from '../shared/strings.mjs';
-
-function magicModuleRequestRouterEntry({
-  host,
-  port
-} = {}) {
-  return createMagicModulePlugin({
-    name: "@quilted/request-router",
-    sideEffects: true,
-    module: MAGIC_MODULE_ENTRY,
-    async source() {
-      const initialContent = multiline`
-        import requestRouter from ${JSON.stringify(
-        MAGIC_MODULE_REQUEST_ROUTER
-      )};
-
-        import {createHttpServer} from '@quilted/quilt/request-router/node';
-
-        const port = ${port ?? "Number.parseInt(process.env.PORT, 10)"};
-        const host = ${host ? JSON.stringify(host) : "process.env.HOST"};
-      
-        createHttpServer(requestRouter).listen(port, host);
-      `;
-      return initialContent;
-    }
-  });
-}
-
-export { magicModuleRequestRouterEntry };