OpenNextJS-AWS

When using #override or #imports directives, do not include import type statements inside these blocks. esbuild will remove the preceding comments (e.g., //#override id) during the build process, which can break the directive.

Instead, place all import type statements outside of the directive blocks. Since types are removed in the final output, this ensures the directives remain intact and functional.

import type { PluginHandler } from "../next-types.js";
import type { IncomingMessage } from "../request.js";
import type { ServerResponse } from "../response.js";

//#override imports
import { requestHandler } from "./util.js";
//#endOverride

When deploying functions, you can use the install option to specify additional packages to be installed in the function environment (e.g., sharp for image optimization). You can also specify the architecture, node version, and libc type.

export interface InstallOptions {
  /**
   * List of packages to install
   * @example
   * ```ts
   * install: {
   *  packages: ["sharp@0.32"]
   * }
   * ```
   */
  packages: string[];
  arch?: "x64" | "arm64";
  nodeVersion?: string;
  libc?: "glibc" | "musl";
  os?: string;
  additionalArgs?: string;
}

Use SplittedFunctionOptions to define specific configurations for individual routes when using the splitting feature. You must specify which routes to include using the routes array with RouteTemplate formats (e.g., app/api/test/route or pages/admin). You can also define CloudFront-compatible patterns (e.g., /api/*).

export interface SplittedFunctionOptions extends FunctionOptions {
  /**
   * Here you should specify all the routes you want to use. 
   * For app routes, you should use the `app/${name}/route` format or `app/${name}/page` for pages. 
   * For pages, you should use the `page/${name}` format.
   */
  routes: RouteTemplate[];
  /**
   * Cloudfront compatible patterns.
   * i.e. /api/*
   * @default []
   */
  patterns: string[];
}

Within the functions object in your open-next.config.ts, you can define specific configurations for different types of functions (e.g., api).

• routes: An array of specific file paths that should be treated as standalone functions.
• patterns: An array of glob patterns (e.g., /api/*) used to match incoming requests to specific functions.

functions: {
  api: {
    routes: ["app/api/client/route", "app/api/host/route", "pages/api/hello"],
    patterns: ["/api/*"],
  },
},

OpenNextJS supports cache interception to optimize routing performance. This can be enabled via the global configuration.

Set globalThis.openNextConfig.dangerous.enableCacheInterception to true to enable the cacheInterceptor during the routing process.

OpenNext supports two types of middleware configuration:

1. External Middleware (external: true): The middleware is deployed separately. It can run on node or edge runtimes. It includes an originResolver to resolve origins for internal rewrites (defaults to pattern-env).
2. Internal Middleware (external: false): The middleware is part of the main function deployment.

Both types support an assetResolver to resolve assets in the routing layer.

export type ExternalMiddlewareConfig = DefaultFunctionOptions & CommonMiddlewareConfig & {
  external: true;
  runtime?: "node" | "edge";
  override?: OverrideOptions;
  originResolver?: IncludedOriginResolver | LazyLoadedOverride<OriginResolver>;
};

export type InternalMiddlewareConfig = {
  external: false;
} & CommonMiddlewareConfig;

Use the buildCommand key in open-next.config.ts to specify the command used to build your Next.js application before deployment. This is useful when using monorepos or specific build tools like Turbo.

const config = {
  buildCommand: "npx turbo build",
};