astro/packages/integrations/netlify/src/integration-edge-functions.ts

184 lines
5.1 KiB
TypeScript
Raw Normal View History

2022-06-07 15:43:33 +00:00
import type { AstroAdapter, AstroConfig, AstroIntegration, BuildConfig, RouteData } from 'astro';
import esbuild from 'esbuild';
import * as fs from 'fs';
import * as npath from 'path';
2022-06-07 15:43:33 +00:00
import { fileURLToPath } from 'url';
2022-06-21 12:33:55 +00:00
import type { Plugin as VitePlugin } from 'vite';
2022-06-07 15:43:33 +00:00
import { createRedirects } from './shared.js';
const SHIM = `globalThis.process = {
argv: [],
env: {},
};`;
export function getAdapter(): AstroAdapter {
return {
name: '@astrojs/netlify/edge-functions',
serverEntrypoint: '@astrojs/netlify/netlify-edge-functions.js',
exports: ['default'],
};
}
interface NetlifyEdgeFunctionsOptions {
dist?: URL;
}
interface NetlifyEdgeFunctionManifestFunctionPath {
function: string;
path: string;
}
interface NetlifyEdgeFunctionManifestFunctionPattern {
function: string;
pattern: string;
}
2022-04-19 15:23:07 +00:00
type NetlifyEdgeFunctionManifestFunction =
| NetlifyEdgeFunctionManifestFunctionPath
| NetlifyEdgeFunctionManifestFunctionPattern;
interface NetlifyEdgeFunctionManifest {
functions: NetlifyEdgeFunctionManifestFunction[];
version: 1;
}
async function createEdgeManifest(routes: RouteData[], entryFile: string, dir: URL) {
const functions: NetlifyEdgeFunctionManifestFunction[] = [];
2022-04-19 15:23:07 +00:00
for (const route of routes) {
if (route.pathname) {
functions.push({
function: entryFile,
path: route.pathname,
});
} else {
functions.push({
function: entryFile,
pattern: route.pattern.toString(),
2022-04-19 15:23:07 +00:00
});
}
}
2022-04-19 15:23:07 +00:00
const manifest: NetlifyEdgeFunctionManifest = {
functions,
version: 1,
};
2022-04-19 17:14:44 +00:00
const baseDir = new URL('./.netlify/edge-functions/', dir);
await fs.promises.mkdir(baseDir, { recursive: true });
const manifestURL = new URL('./manifest.json', baseDir);
2022-04-19 15:23:07 +00:00
const _manifest = JSON.stringify(manifest, null, ' ');
await fs.promises.writeFile(manifestURL, _manifest, 'utf-8');
}
async function bundleServerEntry(buildConfig: BuildConfig, vite: any) {
const entryUrl = new URL(buildConfig.serverEntry, buildConfig.server);
const pth = fileURLToPath(entryUrl);
await esbuild.build({
target: 'es2020',
platform: 'browser',
entryPoints: [pth],
outfile: pth,
allowOverwrite: true,
format: 'esm',
bundle: true,
2022-06-07 15:43:33 +00:00
external: ['@astrojs/markdown-remark'],
banner: {
js: SHIM,
2022-06-27 21:22:26 +00:00
},
});
// Remove chunks, if they exist. Since we have bundled via esbuild these chunks are trash.
try {
2022-06-07 15:43:33 +00:00
const chunkFileNames =
vite?.build?.rollupOptions?.output?.chunkFileNames ?? 'chunks/chunk.[hash].mjs';
const chunkPath = npath.dirname(chunkFileNames);
const chunksDirUrl = new URL(chunkPath + '/', buildConfig.server);
await fs.promises.rm(chunksDirUrl, { recursive: true, force: true });
} catch {}
}
export function netlifyEdgeFunctions({ dist }: NetlifyEdgeFunctionsOptions = {}): AstroIntegration {
let _config: AstroConfig;
let entryFile: string;
let _buildConfig: BuildConfig;
let _vite: any;
return {
name: '@astrojs/netlify/edge-functions',
hooks: {
'astro:config:setup': ({ config, updateConfig }) => {
if (dist) {
config.outDir = dist;
} else {
config.outDir = new URL('./dist/', config.root);
}
// Add a plugin that shims the global environment.
const injectPlugin: VitePlugin = {
name: '@astrojs/netlify/plugin-inject',
generateBundle(_options, bundle) {
2022-06-21 12:33:55 +00:00
if (_buildConfig.serverEntry in bundle) {
const chunk = bundle[_buildConfig.serverEntry];
2022-06-21 12:33:55 +00:00
if (chunk && chunk.type === 'chunk') {
chunk.code = `globalThis.process = { argv: [], env: {}, };${chunk.code}`;
}
}
2022-06-21 12:33:55 +00:00
},
};
updateConfig({
vite: {
2022-06-21 12:33:55 +00:00
plugins: [injectPlugin],
},
});
},
'astro:config:done': ({ config, setAdapter }) => {
setAdapter(getAdapter());
_config = config;
2022-07-25 04:20:38 +00:00
if (config.output === 'static') {
console.warn(`[@astrojs/netlify] \`output: "server"\` is required to use this adapter.`);
2022-07-25 04:20:38 +00:00
console.warn(
`[@astrojs/netlify] Otherwise, this adapter is not required to deploy a static site to Netlify.`
);
}
},
'astro:build:start': async ({ buildConfig }) => {
_buildConfig = buildConfig;
entryFile = buildConfig.serverEntry.replace(/\.m?js/, '');
buildConfig.client = _config.outDir;
buildConfig.server = new URL('./.netlify/edge-functions/', _config.root);
buildConfig.serverEntry = 'entry.js';
},
'astro:build:setup': ({ vite, target }) => {
if (target === 'server') {
_vite = vite;
vite.resolve = vite.resolve || {};
vite.resolve.alias = vite.resolve.alias || {};
const aliases = [{ find: 'react-dom/server', replacement: 'react-dom/server.browser' }];
if (Array.isArray(vite.resolve.alias)) {
vite.resolve.alias = [...vite.resolve.alias, ...aliases];
} else {
for (const alias of aliases) {
(vite.resolve.alias as Record<string, string>)[alias.find] = alias.replacement;
}
}
vite.ssr = {
noExternal: true,
};
}
},
'astro:build:done': async ({ routes, dir }) => {
await bundleServerEntry(_buildConfig, _vite);
await createEdgeManifest(routes, entryFile, _config.root);
await createRedirects(routes, dir, entryFile, true);
},
},
};
}
2022-04-19 15:23:07 +00:00
export { netlifyEdgeFunctions as default };