Merge 5f582b2 into ea35eae

Author: ascorbic

cypress/integration/default/api.spec.ts

@@ -0,0 +1,12 @@
+describe('Extended API routes', () => {
+  it('returns HTTP 202 Accepted for background route', () => {
+    cy.request('/api/hello-background').then((response) => {
+      expect(response.status).to.equal(202)
+    })
+  })
+  it('returns 404 for scheduled route', () => {
+    cy.request('/api/hello-scheduled').then((response) => {
+      expect(response.status).to.equal(404)
+    })
+  })
+})

demos/default/pages/api/hello-background.ts

@@ -0,0 +1,9 @@
+export default (req, res) => {
+  res.setHeader('Content-Type', 'application/json')
+  res.status(200)
+  res.json({ message: 'hello world :)' })
+}
+
+export const config = {
+  type: 'experimental-background',
+}

demos/default/pages/api/hello-scheduled.js

@@ -0,0 +1,10 @@
+export default (req, res) => {
+  res.setHeader('Content-Type', 'application/json')
+  res.status(200)
+  res.json({ message: 'hello world :)' })
+}
+
+export const config = {
+  type: 'experimental-scheduled',
+  schedule: '@hourly',
+}

plugin/src/helpers/analysis.ts

@@ -0,0 +1,103 @@
+import fs from 'fs'
+
+import { extractExportedConstValue, UnsupportedValueError } from 'next/dist/build/analysis/extract-const-value'
+import { parseModule } from 'next/dist/build/analysis/parse-module'
+import { relative } from 'pathe'
+
+export interface ApiStandardConfig {
+  type?: never
+  runtime?: 'nodejs' | 'experimental-edge'
+  schedule?: never
+}
+
+export interface ApiScheduledConfig {
+  type: 'experimental-scheduled'
+  runtime?: 'nodejs'
+  schedule: string
+}
+
+export interface ApiBackgroundConfig {
+  type: 'experimental-background'
+  runtime?: 'nodejs'
+  schedule?: never
+}
+
+export type ApiConfig = ApiStandardConfig | ApiScheduledConfig | ApiBackgroundConfig
+
+export const validateConfigValue = (config: ApiConfig, apiFilePath: string): config is ApiConfig => {
+  if (config.type === 'experimental-scheduled') {
+    if (!config.schedule) {
+      console.error(
+        `Invalid config value in ${relative(
+          process.cwd(),
+          apiFilePath,
+        )}: schedule is required when type is "experimental-scheduled"`,
+      )
+      return false
+    }
+    if ((config as ApiConfig).runtime === 'experimental-edge') {
+      console.error(
+        `Invalid config value in ${relative(
+          process.cwd(),
+          apiFilePath,
+        )}: edge runtime is not supported for scheduled functions`,
+      )
+      return false
+    }
+    return true
+  }
+
+  if (!config.type || config.type === 'experimental-background') {
+    if (config.schedule) {
+      console.error(
+        `Invalid config value in ${relative(
+          process.cwd(),
+          apiFilePath,
+        )}: schedule is not allowed unless type is "experimental-scheduled"`,
+      )
+      return false
+    }
+    if (config.type && (config as ApiConfig).runtime === 'experimental-edge') {
+      console.error(
+        `Invalid config value in ${relative(
+          process.cwd(),
+          apiFilePath,
+        )}: edge runtime is not supported for background functions`,
+      )
+      return false
+    }
+    return true
+  }
+  console.error(
+    `Invalid config value in ${relative(process.cwd(), apiFilePath)}: type ${
+      (config as ApiConfig).type
+    } is not supported`,
+  )
+  return false
+}
+
+/**
+ * Uses Next's swc static analysis to extract the config values from a file.
+ */
+export const extractConfigFromFile = async (apiFilePath: string): Promise<ApiConfig> => {
+  const fileContent = await fs.promises.readFile(apiFilePath, 'utf8')
+  // No need to parse if there's no "config"
+  if (!fileContent.includes('config')) {
+    return {}
+  }
+  const ast = await parseModule(apiFilePath, fileContent)
+
+  let config: ApiConfig
+  try {
+    config = extractExportedConstValue(ast, 'config')
+  } catch (error) {
+    if (error instanceof UnsupportedValueError) {
+      console.warn(`Unsupported config value in ${relative(process.cwd(), apiFilePath)}`)
+    }
+    return {}
+  }
+  if (validateConfigValue(config, apiFilePath)) {
+    return config
+  }
+  throw new Error(`Unsupported config value in ${relative(process.cwd(), apiFilePath)}`)
+}

plugin/src/helpers/config.ts

@@ -89,7 +89,7 @@ export const configureHandlerFunctions = async ({ netlifyConfig, publish, ignore
   netlifyConfig.functions._ipx.node_bundler = 'nft'
 
   /* eslint-enable no-underscore-dangle */
-  ;[HANDLER_FUNCTION_NAME, ODB_FUNCTION_NAME].forEach((functionName) => {
+  ;[HANDLER_FUNCTION_NAME, ODB_FUNCTION_NAME, '_api_*'].forEach((functionName) => {
     netlifyConfig.functions[functionName] ||= { included_files: [], external_node_modules: [] }
     netlifyConfig.functions[functionName].node_bundler = 'nft'
     netlifyConfig.functions[functionName].included_files ||= []

plugin/src/helpers/files.ts

@@ -8,7 +8,7 @@ import globby from 'globby'
 import { PrerenderManifest } from 'next/dist/build'
 import { outdent } from 'outdent'
 import pLimit from 'p-limit'
-import { join } from 'pathe'
+import { join, resolve } from 'pathe'
 import slash from 'slash'
 
 import { MINIMUM_REVALIDATE_SECONDS, DIVIDER } from '../constants'
@@ -325,6 +325,30 @@ const getServerFile = (root: string, includeBase = true) => {
   return findModuleFromBase({ candidates, paths: [root] })
 }
 
+/**
+ * Find the source file for a given page route
+ */
+export const getSourceFileForPage = (page: string, root: string) => {
+  for (const extension of ['ts', 'js']) {
+    const file = join(root, `${page}.${extension}`)
+    if (existsSync(file)) {
+      return file
+    }
+  }
+}
+
+/**
+ * Reads the node file trace file for a given file, and resolves the dependencies
+ */
+export const getDependenciesOfFile = async (file: string) => {
+  const nft = `${file}.nft.json`
+  if (!existsSync(nft)) {
+    return []
+  }
+  const dependencies = await readJson(nft, 'utf8')
+  return dependencies.files.map((dep) => resolve(file, dep))
+}
+
 const baseServerReplacements: Array<[string, string]> = [
   [`let ssgCacheKey = `, `let ssgCacheKey = process.env._BYPASS_SSG || `],
 ]

plugin/src/helpers/functions.ts

@@ -1,29 +1,63 @@
 import type { NetlifyConfig, NetlifyPluginConstants } from '@netlify/build'
 import bridgeFile from '@vercel/node-bridge'
-import { copyFile, ensureDir, writeFile, writeJSON } from 'fs-extra'
+import { copyFile, ensureDir, readJSON, writeFile, writeJSON } from 'fs-extra'
 import type { ImageConfigComplete, RemotePattern } from 'next/dist/shared/lib/image-config'
 import { join, relative, resolve } from 'pathe'
 
 import { HANDLER_FUNCTION_NAME, ODB_FUNCTION_NAME, IMAGE_FUNCTION_NAME, DEFAULT_FUNCTIONS_SRC } from '../constants'
+import { getApiHandler } from '../templates/getApiHandler'
 import { getHandler } from '../templates/getHandler'
-import { getPageResolver } from '../templates/getPageResolver'
+import { getPageResolver, getSinglePageResolver } from '../templates/getPageResolver'
+
+import { ApiConfig, extractConfigFromFile } from './analysis'
+import { getSourceFileForPage } from './files'
+import { getFunctionNameForPage } from './utils'
+
+export interface ApiRouteConfig {
+  route: string
+  config: ApiConfig
+  compiled: string
+}
 
 export const generateFunctions = async (
   { FUNCTIONS_SRC = DEFAULT_FUNCTIONS_SRC, INTERNAL_FUNCTIONS_SRC, PUBLISH_DIR }: NetlifyPluginConstants,
   appDir: string,
+  apiRoutes: Array<ApiRouteConfig>,
 ): Promise<void> => {
-  const functionsDir = INTERNAL_FUNCTIONS_SRC || FUNCTIONS_SRC
-  const functionDir = join(process.cwd(), functionsDir, HANDLER_FUNCTION_NAME)
-  const publishDir = relative(functionDir, resolve(PUBLISH_DIR))
+  const publish = resolve(PUBLISH_DIR)
+  const functionsDir = resolve(INTERNAL_FUNCTIONS_SRC || FUNCTIONS_SRC)
+  console.log({ functionsDir })
+  const functionDir = join(functionsDir, HANDLER_FUNCTION_NAME)
+  const publishDir = relative(functionDir, publish)
+
+  for (const { route, config, compiled } of apiRoutes) {
+    const apiHandlerSource = await getApiHandler({
+      page: route,
+      config,
+    })
+    const functionName = getFunctionNameForPage(route, config.type === 'experimental-background')
+    await ensureDir(join(functionsDir, functionName))
+    await writeFile(join(functionsDir, functionName, `${functionName}.js`), apiHandlerSource)
+    await copyFile(bridgeFile, join(functionsDir, functionName, 'bridge.js'))
+    await copyFile(
+      join(__dirname, '..', '..', 'lib', 'templates', 'handlerUtils.js'),
+      join(functionsDir, functionName, 'handlerUtils.js'),
+    )
+    const resolverSource = await getSinglePageResolver({
+      functionsDir,
+      sourceFile: join(publish, 'server', compiled),
+    })
+    await writeFile(join(functionsDir, functionName, 'pages.js'), resolverSource)
+  }
 
-  const writeHandler = async (func: string, isODB: boolean) => {
+  const writeHandler = async (functionName: string, isODB: boolean) => {
     const handlerSource = await getHandler({ isODB, publishDir, appDir: relative(functionDir, appDir) })
-    await ensureDir(join(functionsDir, func))
-    await writeFile(join(functionsDir, func, `${func}.js`), handlerSource)
-    await copyFile(bridgeFile, join(functionsDir, func, 'bridge.js'))
+    await ensureDir(join(functionsDir, functionName))
+    await writeFile(join(functionsDir, functionName, `${functionName}.js`), handlerSource)
+    await copyFile(bridgeFile, join(functionsDir, functionName, 'bridge.js'))
     await copyFile(
       join(__dirname, '..', '..', 'lib', 'templates', 'handlerUtils.js'),
-      join(functionsDir, func, 'handlerUtils.js'),
+      join(functionsDir, functionName, 'handlerUtils.js'),
     )
   }
 
@@ -105,3 +139,18 @@ export const setupImageFunction = async ({
     })
   }
 }
+
+/**
+ * Look for API routes, and extract the config from the source file.
+ */
+export const getApiRouteConfigs = async (publish: string, baseDir: string): Promise<Array<ApiRouteConfig>> => {
+  const pages = await readJSON(join(publish, 'server', 'pages-manifest.json'))
+  const apiRoutes = Object.keys(pages).filter((page) => page.startsWith('/api/'))
+  const pagesDir = join(baseDir, 'pages')
+  return Promise.all(
+    apiRoutes.map(async (apiRoute) => {
+      const filePath = getSourceFileForPage(apiRoute, pagesDir)
+      return { route: apiRoute, config: await extractConfigFromFile(filePath), compiled: pages[apiRoute] }
+    }),
+  )
+}

plugin/src/helpers/redirects.ts

@@ -10,6 +10,7 @@ import { join } from 'pathe'
 import { HANDLER_FUNCTION_PATH, HIDDEN_PATHS, ODB_FUNCTION_PATH } from '../constants'
 
 import { getMiddleware } from './files'
+import { ApiRouteConfig } from './functions'
 import { RoutesManifest } from './types'
 import {
   getApiRewrites,
@@ -219,10 +220,12 @@ export const generateRedirects = async ({
   netlifyConfig,
   nextConfig: { i18n, basePath, trailingSlash, appDir },
   buildId,
+  apiRoutes,
 }: {
   netlifyConfig: NetlifyConfig
   nextConfig: Pick<NextConfig, 'i18n' | 'basePath' | 'trailingSlash' | 'appDir'>
   buildId: string
+  apiRoutes: Array<ApiRouteConfig>
 }) => {
   const { dynamicRoutes: prerenderedDynamicRoutes, routes: prerenderedStaticRoutes }: PrerenderManifest =
     await readJSON(join(netlifyConfig.build.publish, 'prerender-manifest.json'))
@@ -247,7 +250,7 @@ export const generateRedirects = async ({
   // This is only used in prod, so dev uses `next dev` directly
   netlifyConfig.redirects.push(
     // API routes always need to be served from the regular function
-    ...getApiRewrites(basePath),
+    ...getApiRewrites(basePath, apiRoutes),
     // Preview mode gets forced to the function, to bypass pre-rendered pages, but static files need to be skipped
     ...(await getPreviewRewrites({ basePath, appDir })),
   )

plugin/src/helpers/utils.ts

@@ -1,11 +1,27 @@
+/* eslint-disable max-lines */
 import type { NetlifyConfig } from '@netlify/build'
 import globby from 'globby'
 import { join } from 'pathe'
 
 import { OPTIONAL_CATCH_ALL_REGEX, CATCH_ALL_REGEX, DYNAMIC_PARAMETER_REGEX, HANDLER_FUNCTION_PATH } from '../constants'
 
+import type { ApiRouteConfig } from './functions'
 import { I18n } from './types'
 
+const RESERVED_FILENAME = /[^\w_-]/g
+
+/**
+ * Given a Next route, generates a valid Netlify function name.
+ * If "background" is true then the function name will have `-background`
+ * appended to it, meaning that it is executed as a background function.
+ */
+export const getFunctionNameForPage = (page: string, background = false) =>
+  `${page
+    .replace(CATCH_ALL_REGEX, '_$1-SPLAT')
+    .replace(OPTIONAL_CATCH_ALL_REGEX, '-SPLAT')
+    .replace(DYNAMIC_PARAMETER_REGEX, '_$1-PARAM')
+    .replace(RESERVED_FILENAME, '_')}-${background ? 'background' : 'handler'}`
+
 export const toNetlifyRoute = (nextRoute: string): Array<string> => {
   const netlifyRoutes = [nextRoute]
 
@@ -117,18 +133,38 @@ export const redirectsForNextRouteWithData = ({
     force,
   }))
 
-export const getApiRewrites = (basePath) => [
-  {
-    from: `${basePath}/api`,
-    to: HANDLER_FUNCTION_PATH,
-    status: 200,
-  },
-  {
-    from: `${basePath}/api/*`,
-    to: HANDLER_FUNCTION_PATH,
-    status: 200,
-  },
-]
+export const getApiRewrites = (basePath: string, apiRoutes: Array<ApiRouteConfig>) => {
+  const apiRewrites = apiRoutes.map((apiRoute) => {
+    const [from] = toNetlifyRoute(`${basePath}${apiRoute.route}`)
+
+    // Scheduled functions can't be invoked directly, so we 404 them.
+    if (apiRoute.config.type === 'experimental-scheduled') {
+      return { from, to: '/404.html', status: 404 }
+    }
+    return {
+      from,
+      to: `/.netlify/functions/${getFunctionNameForPage(
+        apiRoute.route,
+        apiRoute.config.type === 'experimental-background',
+      )}`,
+      status: 200,
+    }
+  })
+
+  return [
+    ...apiRewrites,
+    {
+      from: `${basePath}/api`,
+      to: HANDLER_FUNCTION_PATH,
+      status: 200,
+    },
+    {
+      from: `${basePath}/api/*`,
+      to: HANDLER_FUNCTION_PATH,
+      status: 200,
+    },
+  ]
+}
 
 export const getPreviewRewrites = async ({ basePath, appDir }) => {
   const publicFiles = await globby('**/*', { cwd: join(appDir, 'public') })
@@ -185,3 +221,4 @@ export const isNextAuthInstalled = (): boolean => {
     return false
   }
 }
+/* eslint-enable max-lines */