diff --git a/src/dev/middlewares/live_reload.ts b/src/dev/middlewares/live_reload.ts
new file mode 100644
index 00000000000..8e182e420d4
--- /dev/null
+++ b/src/dev/middlewares/live_reload.ts
@@ -0,0 +1,39 @@
+import type { MiddlewareFn } from "../../middlewares/mod.ts";
+import { ALIVE_URL } from "../../constants.ts";
+
+// Live reload: Send updates to browser
+export function liveReload
(): MiddlewareFn {
+ const revision = Date.now();
+
+ return (ctx) => {
+ const { config, req, url } = ctx;
+
+ const aliveUrl = config.basePath + ALIVE_URL;
+
+ if (url.pathname === aliveUrl) {
+ if (req.headers.get("upgrade") !== "websocket") {
+ return new Response(null, { status: 501 });
+ }
+
+ // TODO: When a change is made the Deno server restarts,
+ // so for now the WebSocket connection is only used for
+ // the client to know when the server is back up. Once we
+ // have HMR we'll actively start sending messages back
+ // and forth.
+ const { response, socket } = Deno.upgradeWebSocket(req);
+
+ socket.addEventListener("open", () => {
+ socket.send(
+ JSON.stringify({
+ type: "initial-state",
+ revision,
+ }),
+ );
+ });
+
+ return response;
+ }
+
+ return ctx.next();
+ };
+}
diff --git a/src/dev/mod.ts b/src/dev/mod.ts
index d2d47bb3624..7046d68823a 100644
--- a/src/dev/mod.ts
+++ b/src/dev/mod.ts
@@ -1,111 +1,10 @@
-import {
- greaterOrEqual,
- join,
- relative,
- semverParse,
- walk,
- WalkEntry,
-} from "./deps.ts";
-export { generate, type Manifest } from "./manifest.ts";
-import { generate, type Manifest } from "./manifest.ts";
-import { error } from "./error.ts";
-const MIN_DENO_VERSION = "1.31.0";
-const TEST_FILE_PATTERN = /[._]test\.(?:[tj]sx?|[mc][tj]s)$/;
+import { setMode } from "../runtime/server/mod.tsx";
-export function ensureMinDenoVersion() {
- // Check that the minimum supported Deno version is being used.
- if (
- !greaterOrEqual(
- semverParse(Deno.version.deno),
- semverParse(MIN_DENO_VERSION),
- )
- ) {
- let message =
- `Deno version ${MIN_DENO_VERSION} or higher is required. Please update Deno.\n\n`;
+export { Builder, type FreshBuilder } from "./builder.ts";
+export {
+ type OnTransformArgs,
+ type OnTransformOptions,
+ type TransformFn,
+} from "./file_transformer.ts";
- if (Deno.execPath().includes("homebrew")) {
- message +=
- "You seem to have installed Deno via homebrew. To update, run: `brew upgrade deno`\n";
- } else {
- message += "To update, run: `deno upgrade`\n";
- }
-
- error(message);
- }
-}
-
-async function collectDir(
- dir: string,
- callback: (entry: WalkEntry, dir: string) => void,
- ignoreFilePattern = TEST_FILE_PATTERN,
-): Promise {
- // Check if provided path is a directory
- try {
- const stat = await Deno.stat(dir);
- if (!stat.isDirectory) return;
- } catch (err) {
- if (err instanceof Deno.errors.NotFound) return;
- throw err;
- }
-
- const routesFolder = walk(dir, {
- includeDirs: false,
- includeFiles: true,
- exts: ["tsx", "jsx", "ts", "js"],
- skip: [ignoreFilePattern],
- });
-
- for await (const entry of routesFolder) {
- callback(entry, dir);
- }
-}
-
-const GROUP_REG = /[/\\\\]\((_[^/\\\\]+)\)[/\\\\]/;
-export async function collect(
- directory: string,
- ignoreFilePattern?: RegExp,
-): Promise {
- const filePaths = new Set();
-
- const routes: string[] = [];
- const islands: string[] = [];
- await Promise.all([
- collectDir(join(directory, "./routes"), (entry, dir) => {
- const rel = join("routes", relative(dir, entry.path));
- const normalized = rel.slice(0, rel.lastIndexOf("."));
-
- // A `(_islands)` path segment is a local island folder.
- // Any route path segment wrapped in `(_...)` is ignored
- // during route collection.
- const match = normalized.match(GROUP_REG);
- if (match && match[1].startsWith("_")) {
- if (match[1] === "_islands") {
- islands.push(rel);
- }
- return;
- }
-
- if (filePaths.has(normalized)) {
- throw new Error(
- `Route conflict detected. Multiple files have the same name: ${dir}${normalized}`,
- );
- }
- filePaths.add(normalized);
- routes.push(rel);
- }, ignoreFilePattern),
- collectDir(join(directory, "./islands"), (entry, dir) => {
- const rel = join("islands", relative(dir, entry.path));
- islands.push(rel);
- }, ignoreFilePattern),
- ]);
-
- routes.sort();
- islands.sort();
-
- return { routes, islands };
-}
-
-export async function manifest(path: string, ignoreFilePattern?: RegExp) {
- const manifest = await collect(path, ignoreFilePattern);
- await generate(path, manifest);
-}
+setMode("development");
diff --git a/src/dev/update_check.ts b/src/dev/update_check.ts
index a20cf23e78e..4d6596296c5 100644
--- a/src/dev/update_check.ts
+++ b/src/dev/update_check.ts
@@ -1,4 +1,6 @@
-import { colors, join, lessThan, semverParse } from "./deps.ts";
+import * as semver from "@std/semver";
+import * as colors from "@std/fmt/colors";
+import * as path from "@std/path";
export interface CheckFile {
last_checked: string;
@@ -33,7 +35,7 @@ function getHomeDir(): string | null {
function getFreshCacheDir(): string | null {
const home = getHomeDir();
- if (home) return join(home, "fresh");
+ if (home) return path.join(home, "fresh");
return null;
}
@@ -47,10 +49,9 @@ async function fetchLatestVersion() {
}
async function readCurrentVersion() {
- const versions = (await import("../../versions.json", {
+ return (await import("../../deno.json", {
with: { type: "json" },
- })).default as string[];
- return versions[0];
+ })).default.version;
}
export async function updateCheck(
@@ -70,7 +71,7 @@ export async function updateCheck(
const home = getCacheDir();
if (!home) return;
- const filePath = join(home, "latest.json");
+ const filePath = path.join(home, "latest.json");
try {
await Deno.mkdir(home, { recursive: true });
} catch (err) {
@@ -113,12 +114,12 @@ export async function updateCheck(
}
// Only show update message if current version is smaller than latest
- const currentVersion = semverParse(checkFile.current_version);
- const latestVersion = semverParse(checkFile.latest_version);
+ const currentVersion = semver.parse(checkFile.current_version);
+ const latestVersion = semver.parse(checkFile.latest_version);
if (
(!checkFile.last_shown ||
Date.now() >= new Date(checkFile.last_shown).getTime() + interval) &&
- lessThan(currentVersion, latestVersion)
+ semver.lessThan(currentVersion, latestVersion)
) {
checkFile.last_shown = new Date().toISOString();
diff --git a/src/dev/update_check_test.ts b/src/dev/update_check_test.ts
new file mode 100644
index 00000000000..a4de6b6dbde
--- /dev/null
+++ b/src/dev/update_check_test.ts
@@ -0,0 +1,394 @@
+import * as path from "@std/path";
+import denoJson from "../../deno.json" with { type: "json" };
+import { WEEK } from "@std/datetime";
+import { getStdOutput } from "../../tests/test_utils.tsx";
+import { expect } from "@std/expect";
+import type { CheckFile } from "./update_check.ts";
+
+const CURRENT_VERSION = denoJson.version;
+
+const cwd = import.meta.dirname!;
+
+Deno.test("stores update check file in $HOME/fresh", async () => {
+ const tmpDirName = await Deno.makeTempDir();
+ const filePath = path.join(tmpDirName, "latest.json");
+
+ await new Deno.Command(Deno.execPath(), {
+ args: [
+ "run",
+ "-A",
+ path.join(cwd, "../../tests/fixture_update_check/mod.ts"),
+ ],
+ cwd,
+ env: {
+ CI: "false",
+ TEST_HOME: tmpDirName,
+ },
+ }).output();
+
+ const text = JSON.parse(await Deno.readTextFile(filePath));
+ expect(text).toEqual({
+ current_version: CURRENT_VERSION,
+ latest_version: "99.99.999",
+ last_checked: text.last_checked,
+ last_shown: text.last_shown,
+ });
+
+ await Deno.remove(tmpDirName, { recursive: true });
+});
+
+Deno.test("skips update check on specific environment variables", async (t) => {
+ const envs = ["FRESH_NO_UPDATE_CHECK", "CI", "DENO_DEPLOYMENT_ID"];
+
+ for (const env of envs) {
+ await t.step(`checking ${env}`, async () => {
+ const tmpDirName = await Deno.makeTempDir();
+ const out = await new Deno.Command(Deno.execPath(), {
+ args: [
+ "run",
+ "-A",
+ path.join(cwd, "../../tests/fixture_update_check/mod.ts"),
+ ],
+ cwd,
+ env: {
+ [env]: "true",
+ TEST_HOME: tmpDirName,
+ LATEST_VERSION: "1.30.0",
+ },
+ stderr: "piped",
+ stdout: "piped",
+ }).output();
+
+ const { stdout } = getStdOutput(out);
+ expect(stdout).not.toMatch(/Fresh 1\.30\.0 is available/);
+
+ await Deno.remove(tmpDirName, { recursive: true });
+ });
+ }
+});
+
+Deno.test("shows update message on version mismatch", async () => {
+ const tmpDirName = await Deno.makeTempDir();
+ const filePath = path.join(tmpDirName, "latest.json");
+
+ await Deno.writeTextFile(
+ filePath,
+ JSON.stringify({
+ current_version: "1.1.0",
+ latest_version: "1.1.0",
+ last_checked: new Date(0).toISOString(),
+ }),
+ );
+
+ const out = await new Deno.Command(Deno.execPath(), {
+ args: [
+ "run",
+ "-A",
+ path.join(cwd, "../../tests/fixture_update_check/mod.ts"),
+ ],
+ cwd,
+ env: {
+ CI: "false",
+ TEST_HOME: tmpDirName,
+ LATEST_VERSION: "999.999.0",
+ },
+ stderr: "piped",
+ stdout: "piped",
+ }).output();
+
+ const { stdout } = getStdOutput(out);
+ expect(stdout).toMatch(/Fresh 999\.999\.0 is available/);
+
+ // Updates check file
+ const text = JSON.parse(await Deno.readTextFile(filePath));
+ expect(text).toEqual({
+ current_version: CURRENT_VERSION,
+ latest_version: "999.999.0",
+ last_checked: text.last_checked,
+ last_shown: text.last_shown,
+ });
+
+ await Deno.remove(tmpDirName, { recursive: true });
+});
+
+Deno.test("only fetch new version defined by interval", async (t) => {
+ const tmpDirName = await Deno.makeTempDir();
+
+ await t.step("fetches latest version initially", async () => {
+ const out = await new Deno.Command(Deno.execPath(), {
+ args: [
+ "run",
+ "-A",
+ path.join(cwd, "../../tests/fixture_update_check/mod.ts"),
+ ],
+ cwd,
+ env: {
+ CI: "false",
+ UPDATE_INTERVAL: "100000",
+ TEST_HOME: tmpDirName,
+ LATEST_VERSION: "1.30.0",
+ },
+ stderr: "piped",
+ stdout: "piped",
+ }).output();
+
+ const { stdout } = getStdOutput(out);
+ expect(stdout).toMatch(/fetching latest version/);
+ });
+
+ await t.step("should not fetch if interval has not passed", async () => {
+ const out = await new Deno.Command(Deno.execPath(), {
+ args: [
+ "run",
+ "-A",
+ path.join(cwd, "../../tests/fixture_update_check/mod.ts"),
+ ],
+ cwd,
+ env: {
+ CI: "false",
+ UPDATE_INTERVAL: "100000",
+ TEST_HOME: tmpDirName,
+ LATEST_VERSION: "1.30.0",
+ },
+ stderr: "piped",
+ stdout: "piped",
+ }).output();
+
+ const { stdout } = getStdOutput(out);
+ expect(stdout).not.toMatch(/fetching latest version/);
+ });
+
+ await t.step("fetches if interval has passed", async () => {
+ const out = await new Deno.Command(Deno.execPath(), {
+ args: [
+ "run",
+ "-A",
+ path.join(cwd, "../../tests/fixture_update_check/mod.ts"),
+ ],
+ cwd,
+ env: {
+ CI: "false",
+ UPDATE_INTERVAL: "1 ",
+ TEST_HOME: tmpDirName,
+ LATEST_VERSION: "1.30.0",
+ },
+ }).output();
+
+ const { stdout } = getStdOutput(out);
+ expect(stdout).toMatch(/fetching latest version/);
+ });
+
+ await Deno.remove(tmpDirName, { recursive: true });
+});
+
+Deno.test("updates current version in cache file", async () => {
+ const tmpDirName = await Deno.makeTempDir();
+
+ const checkFile: CheckFile = {
+ current_version: "1.2.0",
+ latest_version: "1.2.0",
+ last_checked: new Date(Date.now() - WEEK).toISOString(),
+ };
+
+ await Deno.writeTextFile(
+ path.join(tmpDirName, "latest.json"),
+ JSON.stringify(checkFile, null, 2),
+ );
+
+ const out = await new Deno.Command(Deno.execPath(), {
+ args: [
+ "run",
+ "-A",
+ path.join(cwd, "../../tests/fixture_update_check/mod.ts"),
+ ],
+ cwd,
+ env: {
+ CI: "false",
+ TEST_HOME: tmpDirName,
+ LATEST_VERSION: CURRENT_VERSION,
+ },
+ stderr: "piped",
+ stdout: "piped",
+ }).output();
+
+ const { stdout } = getStdOutput(out);
+ expect(stdout).not.toMatch(/Fresh .* is available/);
+
+ await Deno.remove(tmpDirName, { recursive: true });
+});
+
+Deno.test("only shows update message when current < latest", async () => {
+ const tmpDirName = await Deno.makeTempDir();
+
+ const checkFile: CheckFile = {
+ current_version: "9999.999.0",
+ latest_version: "1.2.0",
+ last_checked: new Date().toISOString(),
+ };
+
+ await Deno.writeTextFile(
+ path.join(tmpDirName, "latest.json"),
+ JSON.stringify(checkFile, null, 2),
+ );
+
+ const out = await new Deno.Command(Deno.execPath(), {
+ args: [
+ "run",
+ "-A",
+ path.join(cwd, "../../tests/fixture_update_check/mod.ts"),
+ ],
+ cwd,
+ env: {
+ CI: "false",
+ TEST_HOME: tmpDirName,
+ LATEST_VERSION: CURRENT_VERSION,
+ CURRENT_VERSION: "99999.9999.0",
+ },
+ stderr: "piped",
+ stdout: "piped",
+ }).output();
+
+ const { stdout } = getStdOutput(out);
+ expect(stdout).not.toMatch(/Fresh .* is available/);
+
+ await Deno.remove(tmpDirName, { recursive: true });
+});
+
+Deno.test("migrates to last_shown property", async () => {
+ const tmpDirName = await Deno.makeTempDir();
+
+ const checkFile: CheckFile = {
+ latest_version: "1.4.0",
+ current_version: "1.2.0",
+ last_checked: new Date().toISOString(),
+ };
+
+ await Deno.writeTextFile(
+ path.join(tmpDirName, "latest.json"),
+ JSON.stringify(checkFile, null, 2),
+ );
+
+ const out = await new Deno.Command(Deno.execPath(), {
+ args: [
+ "run",
+ "-A",
+ path.join(cwd, "../../tests/fixture_update_check/mod.ts"),
+ ],
+ cwd,
+ env: {
+ CI: "false",
+ TEST_HOME: tmpDirName,
+ CURRENT_VERSION: "1.2.0",
+ LATEST_VERSION: "99999.9999.0",
+ },
+ stderr: "piped",
+ stdout: "piped",
+ }).output();
+
+ const { stdout } = getStdOutput(out);
+ expect(stdout).toMatch(/Fresh .* is available/);
+
+ const checkFileAfter = JSON.parse(
+ await Deno.readTextFile(
+ path.join(tmpDirName, "latest.json"),
+ ),
+ );
+
+ // Check if last version was written
+ expect(typeof checkFileAfter.last_shown).toEqual("string");
+
+ await Deno.remove(tmpDirName, { recursive: true });
+});
+
+Deno.test("doesn't show update if last_shown + interval >= today", async () => {
+ const tmpDirName = await Deno.makeTempDir();
+
+ const todayMinus1Hour = new Date();
+ todayMinus1Hour.setHours(todayMinus1Hour.getHours() - 1);
+
+ const checkFile: CheckFile = {
+ current_version: "1.2.0",
+ latest_version: "1.6.0",
+ last_checked: new Date().toISOString(),
+ last_shown: todayMinus1Hour.toISOString(),
+ };
+
+ await Deno.writeTextFile(
+ path.join(tmpDirName, "latest.json"),
+ JSON.stringify(checkFile, null, 2),
+ );
+
+ const out = await new Deno.Command(Deno.execPath(), {
+ args: [
+ "run",
+ "-A",
+ path.join(cwd, "../../tests/fixture_update_check/mod.ts"),
+ ],
+ cwd,
+ env: {
+ CI: "false",
+ TEST_HOME: tmpDirName,
+ CURRENT_VERSION: "1.2.0",
+ LATEST_VERSION: "99999.9999.0",
+ },
+ stderr: "piped",
+ stdout: "piped",
+ }).output();
+
+ const { stdout } = getStdOutput(out);
+ expect(stdout).not.toMatch(/Fresh .* is available/);
+
+ await Deno.remove(tmpDirName, { recursive: true });
+});
+
+Deno.test(
+ "shows update if last_shown + interval < today",
+ async () => {
+ const tmpDirName = await Deno.makeTempDir();
+
+ const yesterday = new Date();
+ yesterday.setDate(yesterday.getDate() - 1);
+
+ const checkFile: CheckFile = {
+ current_version: "1.2.0",
+ latest_version: "99.999.99",
+ last_checked: new Date().toISOString(),
+ last_shown: yesterday.toISOString(),
+ };
+
+ await Deno.writeTextFile(
+ path.join(tmpDirName, "latest.json"),
+ JSON.stringify(checkFile, null, 2),
+ );
+
+ const out = await new Deno.Command(Deno.execPath(), {
+ args: [
+ "run",
+ "-A",
+ path.join(cwd, "../../tests/fixture_update_check/mod.ts"),
+ ],
+ cwd,
+ env: {
+ CI: "false",
+ TEST_HOME: tmpDirName,
+ CURRENT_VERSION: CURRENT_VERSION,
+ LATEST_VERSION: "99999.9999.0",
+ },
+ stderr: "piped",
+ stdout: "piped",
+ }).output();
+
+ const { stdout } = getStdOutput(out);
+ expect(stdout).toMatch(/Fresh .* is available/);
+
+ const checkFileAfter = JSON.parse(
+ await Deno.readTextFile(
+ path.join(tmpDirName, "latest.json"),
+ ),
+ );
+
+ expect(checkFileAfter.last_shown).not.toEqual(yesterday.toISOString());
+
+ await Deno.remove(tmpDirName, { recursive: true });
+ },
+);
diff --git a/src/error.ts b/src/error.ts
new file mode 100644
index 00000000000..e6e2c149531
--- /dev/null
+++ b/src/error.ts
@@ -0,0 +1,155 @@
+import { MODE } from "./runtime/server/mod.tsx";
+
+export function getMessage(status: number): string {
+ switch (status) {
+ case 100:
+ return "Continue";
+ case 101:
+ return "Switching Protocols";
+ case 102:
+ return "Processing (WebDAV)";
+ case 103:
+ return "Early Hints";
+ case 200:
+ return "OK";
+ case 201:
+ return "Created";
+ case 202:
+ return "Accepted";
+ case 203:
+ return "Non-Authoritative Information";
+ case 204:
+ return "No Content";
+ case 205:
+ return "Reset Content";
+ case 206:
+ return "Partial Content";
+ case 207:
+ return "Multi-Status (WebDAV)";
+ case 208:
+ return "Already Reported (WebDAV)";
+ case 226:
+ return "IM Used (HTTP Delta encoding)";
+ case 300:
+ return "Multiple Choices";
+ case 301:
+ return "Moved Permanently";
+ case 302:
+ return "Found";
+ case 303:
+ return "See Other";
+ case 304:
+ return "Not Modified";
+ case 305:
+ return "Use Proxy Deprecated";
+ case 306:
+ return "unused";
+ case 307:
+ return "Temporary Redirect";
+ case 308:
+ return "Permanent Redirect";
+ case 400:
+ return "Bad Request";
+ case 401:
+ return "Unauthorized";
+ case 402:
+ return "Payment Required Experimental";
+ case 403:
+ return "Forbidden";
+ case 404:
+ return "Not Found";
+ case 405:
+ return "Method Not Allowed";
+ case 406:
+ return "Not Acceptable";
+ case 407:
+ return "Proxy Authentication Required";
+ case 408:
+ return "Request Timeout";
+ case 409:
+ return "Conflict";
+ case 410:
+ return "Gone";
+ case 411:
+ return "Length Required";
+ case 412:
+ return "Precondition Failed";
+ case 413:
+ return "Payload Too Large";
+ case 414:
+ return "URI Too Long";
+ case 415:
+ return "Unsupported Media Type";
+ case 416:
+ return "Range Not Satisfiable";
+ case 417:
+ return "Expectation Failed";
+ case 418:
+ return "I'm a teapot";
+ case 421:
+ return "Misdirected Request";
+ case 422:
+ return "Unprocessable Content (WebDAV)";
+ case 423:
+ return "Locked (WebDAV)";
+ case 424:
+ return "Failed Dependency (WebDAV)";
+ case 425:
+ return "Too Early Experimental";
+ case 426:
+ return "Upgrade Required";
+ case 428:
+ return "Precondition Required";
+ case 429:
+ return "Too Many Requests";
+ case 431:
+ return "Request Header Fields Too Large";
+ case 451:
+ return "Unavailable For Legal Reasons";
+ case 500:
+ return "Internal Server Error";
+ case 501:
+ return "Not Implemented";
+ case 502:
+ return "Bad Gateway";
+ case 503:
+ return "Service Unavailable";
+ case 504:
+ return "Gateway Timeout";
+ case 505:
+ return "HTTP Version Not Supported";
+ case 506:
+ return "Variant Also Negotiates";
+ case 507:
+ return "Insufficient Storage (WebDAV)";
+ case 508:
+ return "Loop Detected (WebDAV)";
+ case 510:
+ return "Not Extended";
+ case 511:
+ return "Network Authentication Required";
+ default:
+ return "Internal Server Error";
+ }
+}
+
+export class HttpError {
+ #error: Error | null = null;
+ name = "HttpError";
+ message: string;
+
+ constructor(
+ public status: number,
+ message: string = getMessage(status),
+ public options?: ErrorOptions,
+ ) {
+ this.message = message;
+ if (MODE !== "production") {
+ this.#error = new Error();
+ }
+ }
+
+ get stack(): string | undefined {
+ return this.#error?.stack;
+ }
+}
diff --git a/src/error_test.ts b/src/error_test.ts
new file mode 100644
index 00000000000..da86e97b832
--- /dev/null
+++ b/src/error_test.ts
@@ -0,0 +1,27 @@
+import { expect } from "@std/expect";
+import { MODE, setMode } from "./runtime/server/mod.tsx";
+import { HttpError } from "./error.ts";
+
+Deno.test("HttpError - contains stack in development", () => {
+ const tmp = MODE;
+ setMode("development");
+ try {
+ const err = new HttpError(404);
+ expect(err.status).toEqual(404);
+ expect(typeof err.stack).toEqual("string");
+ } finally {
+ setMode(tmp);
+ }
+});
+
+Deno.test("HttpError - contains no stack in production", () => {
+ const tmp = MODE;
+ setMode("production");
+ try {
+ const err = new HttpError(404);
+ expect(err.status).toEqual(404);
+ expect(err.stack).toEqual(undefined);
+ } finally {
+ setMode(tmp);
+ }
+});
diff --git a/src/finish_setup.tsx b/src/finish_setup.tsx
new file mode 100644
index 00000000000..b3673d22059
--- /dev/null
+++ b/src/finish_setup.tsx
@@ -0,0 +1,54 @@
+import type { ComponentChildren } from "preact";
+
+export function FinishSetup() {
+ return (
+
+
+
+
Finish setting up Fresh
+
+ -
+ Go to your project in Deno Deploy and click the{" "}
+
Settings tab.
+
+ -
+ In the Git Integration section, enter
deno task build
+ {" "}
+ in the Build Command input.
+
+ -
+ Save the changes.
+
+
+
+
+
+
Missing build directory
+
+ Did you forget to run deno task build?
+
+
+
{data.message}
;
+ * });
+ * ```
+ *
+ * When returning data, you can also specify additional properties that will be
+ * used when constructing the response object from the HTML generated by the
+ * page component. For example, you can specify custom headers, a custom status
+ * code, or a list of elements to include in the ``.
+ *
+ * ```tsx
+ * export const handler = defineHandler((ctx) => {
+ * return {
+ * data: { message: "Hello, world!" },
+ * headers: { "Cache-Control": "public, max-age=3600" },
+ * status: 201,
+ * head: [Hello, world!],
+ * };
+ * });
+ * ```
+ *
+ * ### Asynchronous handlers
+ *
+ * The handler function can also be asynchronous. This can be useful if you need
+ * to fetch data from an external source, or perform some other asynchronous
+ * operation before returning a response.
+ *
+ * ```ts
+ * export const handler = defineHandler(async (ctx) => {
+ * const resp = await fetch("https://api.example.com/data").;
+ * if (!resp.ok) {
+ * throw new Error("Failed to fetch data");
+ * }
+ * const data = await resp.json();
+ * return { data };
+ * });
+ * ```
+ *
+ * If you initiate multiple asynchronous operations in a handler, you can use
+ * `Promise.all` to wait for all of them to complete at the same time. This can
+ * speed up the response time of your handler, as it allows you to perform
+ * multiple operations concurrently.
+ *
+ * ```ts
+ * export const handler = defineHandler(async (ctx) => {
+ * const [resp1, resp2] = await Promise.all([
+ * fetch("https://api.example.com/data1")
+ * .then((resp) => resp.json()),
+ * fetch("https://api.example.com/data2")
+ * .then((resp) => resp.json()),
+ * ]);
+ * return { data: { data1, data2 } };
+ * });
+ * ```
+ */
+export interface HandlerFn {
+ (ctx: FreshContext):
+ | Response
+ | Render
+ | void
+ | Promise | void>;
+}
+
+/**
+ * A set of handler functions that routes requests based on the HTTP method.
+ *
+ * See {@link RouteHandler} for more information on how to use this type.
+ */
+export type HandlerByMethod = {
+ [M in Method]?: HandlerFn;
+};
+
+export type RouteData<
+ Handler extends RouteHandler,
+> = Handler extends (RouteHandler) ? Data
+ : never;
diff --git a/src/helpers.ts b/src/helpers.ts
new file mode 100644
index 00000000000..111e327d263
--- /dev/null
+++ b/src/helpers.ts
@@ -0,0 +1,155 @@
+import type { AnyComponent } from "preact";
+import type { HandlerByMethod, RouteHandler } from "./handlers.ts";
+import type { FreshContext } from "./context.ts";
+import type { Middleware } from "./middlewares/mod.ts";
+
+/**
+ * A set of helper functions that enable better type inference and code
+ * completion when defining routes and middleware.
+ *
+ * To create a helpers object, call {@link createHelpers}.
+ */
+export interface Helpers {
+ /**
+ * Define a {@link RouteHandler} object. This function returns the passed
+ * input as-is.
+ *
+ * You can use this function to help the TypeScript compiler infer the types
+ * of your route handlers. For example:
+ *
+ * ```ts
+ * export const handler = helpers.defineHandlers((ctx) => {
+ * ctx.url; // ctx is inferred to be a FreshContext object, so this is a URL
+ * return new Response("Hello, world!");
+ * });
+ * ```
+ *
+ * This is particularly useful when combined with the {@link definePage}
+ * helper function, which can infer the data type from the handler function.
+ * For more information, see {@link definePage}.
+ *
+ * You can also pass an explicit type argument to ensure that all data
+ * returned from the render function is of the correct type:
+ *
+ * ```ts
+ * export const handler = helpers.defineHandlers<{ slug: string }>({
+ * async GET(ctx) {
+ * const slug = ctx.params.slug; // slug is inferred to be a string
+ * return { data: { slug } };
+ * },
+ *
+ * // This method will cause a type error because the data object is missing
+ * // the required `slug` property.
+ * async POST(ctx) {
+ * return { data: { } };
+ * },
+ * });
+ * ```
+ *
+ * @typeParam Data The type of data that the handler returns. This will be inferred from the handler methods if not provided.
+ * @typeParam Handlers This will always be inferred from the input object. Do not manually specify this type.
+ */
+ defineHandlers<
+ Data,
+ Handlers extends RouteHandler = RouteHandler,
+ >(
+ handlers: Handlers,
+ ): typeof handlers;
+
+ /**
+ * Define a page component that will be rendered when a route handler returns
+ * data. This function returns the passed input as-is.
+ *
+ * You can use this function to help the TypeScript compiler infer the types
+ * of the data that your page component receives. For example:
+ *
+ * ```ts
+ * export default helpers.definePage((props) => {
+ * const slug = props.params.slug; // Because props is inferred to be a FreshContext object, slug is inferred to be a string
+ * return {slug}
;
+ * });
+ * ```
+ *
+ * This is particularly useful when combined with the {@link defineHandlers}
+ * helper function, in which case the data type will be inferred from the
+ * return type of the handler method.
+ *
+ * ```ts
+ * export const handler = defineHandlers({
+ * async GET(ctx) {
+ * const slug = ctx.params.slug; // slug is inferred to be a string
+ * return { data: { slug } };
+ * },
+ * });
+ *
+ * export default definePage(({ data }) => {
+ * const slug = data.slug; // slug is inferred to be a string here
+ * return {slug}
;
+ * });
+ * ```
+ *
+ * As a rule of thumb, always use this function to define your page
+ * components. If you also have a handler for this route, pass the handler
+ * object as a type argument to this function. If you do not have a handler,
+ * omit the type argument.
+ *
+ * @typeParam Handler The type of the handler object that this page component is associated with. If this route has a handler, pass the handler object as a type argument to this function, e.g. `typeof handler`. If this route does not have a handler, omit this type argument.
+ * @typeParam Data The type of data that the page component receives. This will be inferred from the handler methods if not provided. In very advanced use cases, you can specify `never` to the `Handler` type argument and provide the `Data` type explicitly.
+ */
+ definePage<
+ Handler extends RouteHandler = never,
+ Data = Handler extends HandlerByMethod ? Data : never,
+ >(
+ render: AnyComponent & { Component: () => null }>,
+ ): typeof render;
+
+ /**
+ * Define a {@link Middleware} that will be used to process requests before
+ * they are passed to the route handler. This function returns the passed
+ * input as-is.
+ *
+ * You can use this function to help the TypeScript compiler infer the types
+ * of the context object that your middleware receives. For example:
+ *
+ * ```ts
+ * export const middleware = helpers.defineMiddleware((ctx) => {
+ * ctx.url; // ctx is inferred to be a FreshContext object, so this is a URL
+ * return ctx.next();
+ * });
+ * ```
+ *
+ * You may also pass an array of middleware functions to this function.
+ *
+ * @typeParam M The type of the middleware function. This will be inferred from the input function. Do not manually specify this type.
+ */
+ defineMiddleware>(
+ middleware: M,
+ ): typeof middleware;
+}
+
+/**
+ * Create a set of helper functions that enable better type inference and code
+ * completion when defining routes and middleware.
+ *
+ * To use, call this function in a central file and export the result. In your
+ * route and middleware files, import the {@link Helpers|helpers object} and use
+ * them to define your routes and middleware using the
+ * {@link Helpers.defineHandlers|defineHandlers},
+ * {@link Helpers.definePage|definePage}, and
+ * {@link Helpers.defineMiddleware|defineMiddleware} functions.
+ *
+ * @typeParam State The type of the state object that is passed to all middleware and route handlers.
+ */
+export function createHelpers(): Helpers {
+ return {
+ defineHandlers(handlers) {
+ return handlers;
+ },
+ definePage(render) {
+ return render;
+ },
+ defineMiddleware(middleware) {
+ return middleware;
+ },
+ };
+}
diff --git a/src/jsonify/constants.ts b/src/jsonify/constants.ts
new file mode 100644
index 00000000000..07a273c7ef0
--- /dev/null
+++ b/src/jsonify/constants.ts
@@ -0,0 +1,7 @@
+export const UNDEFINED = -1;
+export const NULL = -2;
+export const NAN = -3;
+export const INFINITY_POS = -4;
+export const INFINITY_NEG = -5;
+export const ZERO_NEG = -6;
+export const HOLE = -7;
diff --git a/src/jsonify/custom_test.ts b/src/jsonify/custom_test.ts
new file mode 100644
index 00000000000..0aa5ffef32d
--- /dev/null
+++ b/src/jsonify/custom_test.ts
@@ -0,0 +1,54 @@
+import { expect } from "@std/expect";
+import { parse } from "./parse.ts";
+import { stringify } from "./stringify.ts";
+import { Signal, signal } from "@preact/signals";
+
+Deno.test("custom parse - Point", () => {
+ class Point {
+ constructor(public x: number, public y: number) {
+ this.x = x;
+ this.y = y;
+ }
+ }
+
+ const str = stringify(new Point(30, 40), {
+ Point: (value) => value instanceof Point ? [value.x, value.y] : undefined,
+ });
+
+ expect(str).toEqual('[["Point",1],[2,3],30,40]');
+
+ const point = parse(str, {
+ Point: ([x, y]: [number, number]) => new Point(x, y),
+ });
+ expect(point).toEqual(new Point(30, 40));
+});
+
+Deno.test("custom parse - Signals", () => {
+ const res = parse('[["Signal",1],2]', {
+ Signal: (value) => signal(value),
+ });
+ expect(res).toBeInstanceOf(Signal);
+ expect(res.peek()).toEqual(2);
+});
+
+Deno.test("custom stringify - Signals", () => {
+ const s = signal(2);
+ expect(stringify(s, {
+ Signal: (s2: unknown) => {
+ return s2 instanceof Signal ? s2.peek() : undefined;
+ },
+ })).toEqual(
+ '[["Signal",1],2]',
+ );
+});
+
+Deno.test("custom stringify - referenced Signals", () => {
+ const s = signal(2);
+ expect(stringify([s, s], {
+ Signal: (s2: unknown) => {
+ return s2 instanceof Signal ? s2.peek() : undefined;
+ },
+ })).toEqual(
+ '[[1,1],["Signal",2],2]',
+ );
+});
diff --git a/src/jsonify/parse.ts b/src/jsonify/parse.ts
new file mode 100644
index 00000000000..66ed83ca89c
--- /dev/null
+++ b/src/jsonify/parse.ts
@@ -0,0 +1,193 @@
+import {
+ HOLE,
+ INFINITY_NEG,
+ INFINITY_POS,
+ NAN,
+ NULL,
+ UNDEFINED,
+ ZERO_NEG,
+} from "./constants.ts";
+
+// deno-lint-ignore no-explicit-any
+export type CustomParser = Record unknown>;
+
+export function parse(
+ value: string,
+ custom?: CustomParser | undefined,
+): T {
+ const data = JSON.parse(value);
+
+ const hydrated = new Array(data.length);
+ // deno-lint-ignore no-explicit-any
+ unpack(data, hydrated, 0, custom) as any;
+ return hydrated[0];
+}
+
+function unpack(
+ arr: unknown[],
+ hydrated: unknown[],
+ idx: number,
+ custom: CustomParser | undefined,
+): void {
+ if (idx in hydrated) return;
+
+ const current = arr[idx];
+ if (typeof current === "number") {
+ switch (current) {
+ case UNDEFINED:
+ hydrated[idx] = undefined;
+ return;
+ case NULL:
+ hydrated[idx] = null;
+ return;
+ case NAN:
+ hydrated[idx] = NaN;
+ return;
+ case INFINITY_POS:
+ hydrated[idx] = Infinity;
+ return;
+ case INFINITY_NEG:
+ hydrated[idx] = -Infinity;
+ return;
+ case ZERO_NEG:
+ hydrated[idx] = -0;
+ return;
+ default:
+ hydrated[idx] = current;
+ return;
+ }
+ } else if (
+ typeof current === "string" || typeof current === "boolean" ||
+ current === null
+ ) {
+ hydrated[idx] = current;
+ return;
+ } else if (Array.isArray(current)) {
+ if (current.length > 0 && typeof current[0] === "string") {
+ const name = current[0];
+ if (custom !== undefined && name in custom) {
+ const fn = custom[name];
+ const ref = current[1];
+ unpack(arr, hydrated, ref, custom);
+ const value = hydrated[ref];
+ hydrated[idx] = fn(value);
+ return;
+ }
+ switch (name) {
+ case "BigInt":
+ hydrated[idx] = BigInt(current[1]);
+ return;
+ case "Date":
+ hydrated[idx] = new Date(current[1]);
+ return;
+ case "RegExp":
+ hydrated[idx] = new RegExp(current[1], current[2]);
+ return;
+ case "Set": {
+ const set = new Set();
+ for (let i = 0; i < current[1].length; i++) {
+ const ref = current[1][i];
+ unpack(arr, hydrated, ref, custom);
+ set.add(hydrated[ref]);
+ }
+ hydrated[idx] = set;
+ return;
+ }
+ case "Map": {
+ const set = new Map();
+ for (let i = 0; i < current[1].length; i++) {
+ const refKey = current[1][i++];
+ unpack(arr, hydrated, refKey, custom);
+ const refValue = current[1][i];
+ unpack(arr, hydrated, refValue, custom);
+
+ set.set(hydrated[refKey], hydrated[refValue]);
+ }
+ hydrated[idx] = set;
+ return;
+ }
+ case "Uint8Array":
+ hydrated[idx] = b64decode(current[1]);
+ return;
+ }
+ } else {
+ const actual = new Array(current.length);
+ hydrated[idx] = actual;
+ for (let i = 0; i < current.length; i++) {
+ const ref = current[i];
+ if (ref < 0) {
+ switch (ref) {
+ case UNDEFINED:
+ actual[i] = undefined;
+ break;
+ case NULL:
+ actual[i] = null;
+ break;
+ case NAN:
+ actual[i] = NaN;
+ break;
+ case INFINITY_POS:
+ actual[i] = Infinity;
+ break;
+ case INFINITY_NEG:
+ actual[i] = -Infinity;
+ break;
+ case ZERO_NEG:
+ actual[i] = -0;
+ break;
+ case HOLE:
+ continue;
+ }
+ } else {
+ unpack(arr, hydrated, ref, custom);
+ actual[i] = hydrated[ref];
+ }
+ }
+ }
+ } else if (typeof current === "object") {
+ const actual: Record = {};
+ hydrated[idx] = actual;
+
+ const keys = Object.keys(current);
+ for (let i = 0; i < keys.length; i++) {
+ const key = keys[i];
+ // deno-lint-ignore no-explicit-any
+ const ref = (current as any)[key];
+ if (ref < 0) {
+ switch (ref) {
+ case UNDEFINED:
+ actual[key] = undefined;
+ break;
+ case NULL:
+ actual[key] = null;
+ break;
+ case NAN:
+ actual[key] = NaN;
+ break;
+ case INFINITY_POS:
+ actual[key] = Infinity;
+ break;
+ case INFINITY_NEG:
+ actual[key] = -Infinity;
+ break;
+ case ZERO_NEG:
+ actual[key] = -0;
+ break;
+ }
+ } else {
+ unpack(arr, hydrated, ref, custom);
+ actual[key] = hydrated[ref];
+ }
+ }
+ }
+}
+
+function b64decode(b64: string): Uint8Array {
+ const binString = atob(b64);
+ const size = binString.length;
+ const bytes = new Uint8Array(size);
+ for (let i = 0; i < size; i++) {
+ bytes[i] = binString.charCodeAt(i);
+ }
+ return bytes;
+}
diff --git a/src/jsonify/parse_test.ts b/src/jsonify/parse_test.ts
new file mode 100644
index 00000000000..8e5a1b88df1
--- /dev/null
+++ b/src/jsonify/parse_test.ts
@@ -0,0 +1,99 @@
+import { expect } from "@std/expect";
+import { parse } from "./parse.ts";
+
+Deno.test("parse - json", () => {
+ expect(parse("[2]")).toEqual(2);
+ expect(parse('["abc"]')).toEqual("abc");
+ expect(parse("[true]")).toEqual(true);
+ expect(parse("[false]")).toEqual(false);
+ expect(parse("[[1,2,3],1,2,3]")).toEqual([1, 2, 3]);
+ expect(parse('[{"a":1,"b":-2,"c":2},1,[-2]]')).toEqual({
+ a: 1,
+ b: null,
+ c: [null],
+ });
+});
+
+Deno.test("parse - hole array", () => {
+ expect(parse("[[1,-7,2],1,3]")).toEqual([1, , 3]);
+});
+
+Deno.test("parse - undefined", () => {
+ expect(parse("[-1]")).toEqual(undefined);
+});
+
+Deno.test("parse - Infinity", () => {
+ expect(parse("[-4]")).toEqual(Infinity);
+ expect(parse("[-5]")).toEqual(-Infinity);
+});
+
+Deno.test("parse - NaN", () => {
+ expect(parse("[-3]")).toEqual(NaN);
+});
+
+Deno.test("parse - -0", () => {
+ expect(parse("[-6]")).toEqual(-0);
+});
+
+Deno.test("parse - bigint", () => {
+ const n = BigInt(9007199254740991);
+ expect(parse('[["BigInt","9007199254740991"]]')).toEqual(
+ n,
+ );
+});
+
+Deno.test("parse - Set", () => {
+ const res = parse('[["Set",[1,2]],1,{"foo":1}]');
+ expect(res).toEqual(
+ new Set([1, { foo: 1 }]),
+ );
+});
+
+Deno.test("parse - Map", () => {
+ expect(parse('[["Map",[1,2,3,4]],1,{"foo":1},2,3]'))
+ .toEqual(
+ new Map([[1, { foo: 1 }], [2, 3]]),
+ );
+});
+
+Deno.test("parse - Date", () => {
+ const date = new Date("1990-05-31");
+ expect(parse('[["Date","1990-05-31T00:00:00.000Z"]]')).toEqual(
+ date,
+ );
+});
+
+Deno.test("parse - RegExp", () => {
+ let reg = /foo["]/;
+ expect(parse('[["RegExp","foo[\\"]", ""]]')).toEqual(reg);
+
+ reg = /foo["]/g;
+ expect(parse('[["RegExp","foo[\\"]", "g"]]')).toEqual(reg);
+});
+
+Deno.test("parse - Uint8Array", () => {
+ const value = new Uint8Array([1, 2, 3]);
+ expect(parse('[["Uint8Array","AQID"]]')).toEqual(
+ value,
+ );
+});
+
+Deno.test("parse - references", () => {
+ const inner = { foo: 123 };
+ const obj = { a: inner, b: [inner, inner] };
+ const res = parse('[{"a":1,"b":3},{"foo":2},123,[1,1]]');
+ expect(res).toEqual(obj);
+ expect(res.a).toEqual(res.b[0]);
+ expect(res.a).toEqual(res.b[1]);
+});
+
+Deno.test("parse - circular references", () => {
+ // deno-lint-ignore no-explicit-any
+ const foo = { foo: null as any };
+ foo.foo = foo;
+ expect(parse('[{"foo":0}]')).toEqual(foo);
+});
+
+Deno.test("parse - object", () => {
+ expect(parse('[{"foo":1},42]')).toEqual({ foo: 42 });
+});
diff --git a/src/jsonify/stringify.ts b/src/jsonify/stringify.ts
new file mode 100644
index 00000000000..5511e8d713f
--- /dev/null
+++ b/src/jsonify/stringify.ts
@@ -0,0 +1,186 @@
+import {
+ INFINITY_NEG,
+ INFINITY_POS,
+ NAN,
+ NULL,
+ UNDEFINED,
+ ZERO_NEG,
+} from "./constants.ts";
+import { HOLE } from "./constants.ts";
+
+// deno-lint-ignore no-explicit-any
+export type Stringifiers = Record any>;
+
+/**
+ * Serializes the following:
+ *
+ * - `null`
+ * - `undefined`
+ * - `boolean`
+ * - `number`
+ * - `bigint`
+ * - `string`
+ * - `array`
+ * - `object` (no prototypes)
+ * - `Uint8Array`
+ * - `Date`
+ * - `RegExp`
+ * - `Set`
+ * - `Map`
+ *
+ * Circular references are supported and objects with the same reference are
+ * serialized only once.
+ */
+export function stringify(data: unknown, custom?: Stringifiers): string {
+ const out: string[] = [];
+ const indexes = new Map();
+ const res = serializeInner(out, indexes, data, custom);
+ if (res < 0) {
+ out.push(String(res));
+ }
+ return `[${out.join(",")}]`;
+}
+
+function serializeInner(
+ out: string[],
+ indexes: Map,
+ value: unknown,
+ custom: Stringifiers | undefined,
+): number {
+ const seenIdx = indexes.get(value);
+ if (seenIdx !== undefined) return seenIdx;
+
+ if (value === undefined) return UNDEFINED;
+ if (value === null) return NULL;
+ if (Number.isNaN(value)) return NAN;
+ if (value === Infinity) return INFINITY_POS;
+ if (value === -Infinity) return INFINITY_NEG;
+ if (value === 0 && 1 / value < 0) return ZERO_NEG;
+
+ const idx = out.length;
+ out.push("");
+ indexes.set(value, idx);
+
+ let str = "";
+
+ if (typeof value === "number") {
+ str += String(value);
+ } else if (typeof value === "boolean") {
+ str += String(value);
+ } else if (typeof value === "bigint") {
+ str += `["BigInt","${value}"]`;
+ } else if (typeof value === "string") {
+ str += JSON.stringify(value);
+ } else if (Array.isArray(value)) {
+ str += "[";
+ for (let i = 0; i < value.length; i++) {
+ if (i in value) {
+ str += serializeInner(out, indexes, value[i], custom);
+ } else {
+ str += HOLE;
+ }
+
+ if (i < value.length - 1) {
+ str += ",";
+ }
+ }
+ str += "]";
+ } else if (typeof value === "object") {
+ if (custom !== undefined) {
+ for (const k in custom) {
+ const fn = custom[k];
+ if (fn === undefined) continue;
+
+ const res = fn(value);
+ if (res === undefined) continue;
+
+ serializeInner(out, indexes, res, custom);
+ str = `["${k}",${idx + 1}]`;
+ out[idx] = str;
+ return idx;
+ }
+ }
+
+ if (value instanceof Date) {
+ str += `["Date","${value.toISOString()}"]`;
+ } else if (value instanceof RegExp) {
+ str += `["RegExp",${JSON.stringify(value.source)}, "${value.flags}"]`;
+ } else if (value instanceof Uint8Array) {
+ str += `["Uint8Array","${b64encode(value)}"]`;
+ } else if (value instanceof Set) {
+ const items = new Array(value.size);
+ let i = 0;
+ value.forEach((v) => {
+ items[i++] = serializeInner(out, indexes, v, custom);
+ });
+ str += `["Set",[${items.join(",")}]]`;
+ } else if (value instanceof Map) {
+ const items = new Array(value.size * 2);
+ let i = 0;
+ value.forEach((v, k) => {
+ items[i++] = serializeInner(out, indexes, k, custom);
+ items[i++] = serializeInner(out, indexes, v, custom);
+ });
+ str += `["Map",[${items.join(",")}]]`;
+ } else {
+ str += "{";
+ const keys = Object.keys(value);
+ for (let i = 0; i < keys.length; i++) {
+ const key = keys[i];
+ str += JSON.stringify(key) + ":";
+ // deno-lint-ignore no-explicit-any
+ str += serializeInner(out, indexes, (value as any)[key], custom);
+
+ if (i < keys.length - 1) {
+ str += ",";
+ }
+ }
+ str += "}";
+ }
+ } else if (typeof value === "function") {
+ throw new Error(`Serializing functions is not supported.`);
+ }
+
+ out[idx] = str;
+ return idx;
+}
+
+// deno-fmt-ignore
+const base64abc = [
+ "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O",
+ "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "a", "b", "c", "d",
+ "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s",
+ "t", "u", "v", "w", "x", "y", "z", "0", "1", "2", "3", "4", "5", "6", "7",
+ "8", "9", "+", "/",
+];
+
+/**
+ * CREDIT: https://gist.github.com/enepomnyaschih/72c423f727d395eeaa09697058238727
+ * Encodes a given Uint8Array, ArrayBuffer or string into RFC4648 base64 representation
+ */
+export function b64encode(buffer: ArrayBuffer): string {
+ const uint8 = new Uint8Array(buffer);
+ let result = "",
+ i;
+ const l = uint8.length;
+ for (i = 2; i < l; i += 3) {
+ result += base64abc[uint8[i - 2] >> 2];
+ result += base64abc[((uint8[i - 2] & 0x03) << 4) | (uint8[i - 1] >> 4)];
+ result += base64abc[((uint8[i - 1] & 0x0f) << 2) | (uint8[i] >> 6)];
+ result += base64abc[uint8[i] & 0x3f];
+ }
+ if (i === l + 1) {
+ // 1 octet yet to write
+ result += base64abc[uint8[i - 2] >> 2];
+ result += base64abc[(uint8[i - 2] & 0x03) << 4];
+ result += "==";
+ }
+ if (i === l) {
+ // 2 octets yet to write
+ result += base64abc[uint8[i - 2] >> 2];
+ result += base64abc[((uint8[i - 2] & 0x03) << 4) | (uint8[i - 1] >> 4)];
+ result += base64abc[(uint8[i - 1] & 0x0f) << 2];
+ result += "=";
+ }
+ return result;
+}
diff --git a/src/jsonify/stringify_test.ts b/src/jsonify/stringify_test.ts
new file mode 100644
index 00000000000..912dda67380
--- /dev/null
+++ b/src/jsonify/stringify_test.ts
@@ -0,0 +1,109 @@
+import { expect } from "@std/expect";
+import { stringify } from "./stringify.ts";
+
+Deno.test("stringify - json", () => {
+ expect(stringify(2)).toEqual("[2]");
+ expect(stringify("abc")).toEqual('["abc"]');
+ expect(stringify(true)).toEqual("[true]");
+ expect(stringify(false)).toEqual("[false]");
+ expect(stringify([1, 2, 3])).toEqual("[[1,2,3],1,2,3]");
+ expect(stringify({ a: 1, b: null, c: [null] })).toEqual(
+ '[{"a":1,"b":-2,"c":2},1,[-2]]',
+ );
+});
+
+Deno.test("stringify - hole array", () => {
+ expect(stringify([1, , 3])).toEqual("[[1,-7,2],1,3]");
+});
+
+Deno.test("stringify - undefined", () => {
+ expect(stringify(undefined)).toEqual("[-1]");
+});
+
+Deno.test("stringify - Infinity", () => {
+ expect(stringify(Infinity)).toEqual("[-4]");
+ expect(stringify(-Infinity)).toEqual("[-5]");
+});
+
+Deno.test("stringify - NaN", () => {
+ expect(stringify(NaN)).toEqual("[-3]");
+});
+
+Deno.test("stringify - -0", () => {
+ expect(stringify(-0)).toEqual("[-6]");
+});
+
+Deno.test("stringify - bigint", () => {
+ const n = BigInt(9007199254740991);
+ expect(stringify(n)).toEqual(
+ '[["BigInt","9007199254740991"]]',
+ );
+});
+
+Deno.test("stringify - Date", () => {
+ const date = new Date("1990-05-31");
+ expect(stringify(date)).toEqual(
+ '[["Date","1990-05-31T00:00:00.000Z"]]',
+ );
+});
+
+Deno.test("stringify - RegExp", () => {
+ let reg = /foo["]/;
+ expect(stringify(reg)).toEqual(
+ '[["RegExp","foo[\\"]", ""]]',
+ );
+
+ reg = /foo["]/g;
+ expect(stringify(reg)).toEqual(
+ '[["RegExp","foo[\\"]", "g"]]',
+ );
+});
+
+Deno.test("stringify - Set", () => {
+ expect(stringify(new Set([1, { foo: 1 }]))).toEqual(
+ '[["Set",[1,2]],1,{"foo":1}]',
+ );
+});
+
+Deno.test("stringify - Map", () => {
+ expect(stringify(new Map([[1, { foo: 1 }], [2, 3]])))
+ .toEqual(
+ '[["Map",[1,2,3,4]],1,{"foo":1},2,3]',
+ );
+});
+
+Deno.test("stringify - Uint8Array", () => {
+ const value = new Uint8Array([1, 2, 3]);
+ expect(stringify(value)).toEqual(
+ '[["Uint8Array","AQID"]]',
+ );
+});
+
+Deno.test("stringify - references", () => {
+ const inner = { foo: 123 };
+ const obj = { a: inner, b: [inner, inner] };
+ expect(stringify(obj)).toEqual(
+ '[{"a":1,"b":3},{"foo":2},123,[1,1]]',
+ );
+});
+
+Deno.test("stringify - circular references", () => {
+ // deno-lint-ignore no-explicit-any
+ const foo = { foo: null as any };
+ foo.foo = foo;
+ expect(stringify(foo)).toEqual(
+ '[{"foo":0}]',
+ );
+});
+
+Deno.test("stringify - object prototype", () => {
+ const obj = { __proto__: 123, foo: 1 };
+ expect(stringify(obj)).toEqual(
+ '[{"foo":1},1]',
+ );
+});
+
+Deno.test("stringify - throw serializing functions", () => {
+ const fn = () => {};
+ expect(() => stringify(fn)).toThrow();
+});
diff --git a/src/middlewares/mod.ts b/src/middlewares/mod.ts
new file mode 100644
index 00000000000..a6b5028f14d
--- /dev/null
+++ b/src/middlewares/mod.ts
@@ -0,0 +1,107 @@
+import type { FreshContext } from "../context.ts";
+import type { App as _App } from "../app.ts";
+
+/**
+ * A middleware function is the basic building block of Fresh. It allows you
+ * to respond to an incoming request in any way you want. You can redirect
+ * routes, serve files, create APIs and much more. Middlewares can be chained by
+ * calling {@linkcode FreshContext.next|ctx.next()} inside of the function.
+ *
+ * Middlewares can be synchronous or asynchronous. If a middleware returns a
+ * {@linkcode Response} object, the response will be sent back to the client. If
+ * a middleware returns a `Promise`, Fresh will wait for the promise
+ * to resolve before sending the response.
+ *
+ * A {@linkcode FreshContext} object is passed to the middleware function. This
+ * object contains the original request object, as well as any state related to
+ * the current request. The context object also contains methods to redirect
+ * the client to another URL, or to call the next middleware in the chain.
+ *
+ * Middlewares can be defined as a single function or an array of functions.
+ * When an array of middlewares is passed to
+ * {@linkcode _App.prototype.use|app.use}, Fresh will call each middleware in the
+ * order they are defined.
+ *
+ * Middlewares can also be defined using the
+ * {@linkcode _App.prototype.defineMiddleware|app.defineMiddleware} method. This
+ * method is optional, but it can be useful for type checking and code
+ * completion. It does not register the middleware with the app.
+ *
+ * ## Examples
+ *
+ * ### Logging middleware
+ *
+ * This example shows how to create a simple middleware that logs incoming
+ * requests.
+ *
+ * ```ts
+ * // Define a middleware function that logs incoming requests. Using the
+ * // `defineMiddleware` method is optional, but it can be useful for type
+ * // checking and code completion. It does not register the middleware with the
+ * // app.
+ * const loggerMiddleware = app.defineMiddleware((ctx) => {
+ * console.log(`${ctx.req.method} ${ctx.req.url}`);
+ * // Call the next middleware
+ * return ctx.next();
+ * });
+ *
+ * // To register the middleware to the app, use `app.use`.
+ * app.use(loggerMiddleware)
+ * ```
+ *
+ * ### Redirect middleware
+ *
+ * This example shows how to create a middleware that redirects requests from
+ * one URL to another.
+ *
+ * ```ts
+ * // Any request to a URL that starts with "/legacy/" will be redirected to
+ * // "/modern".
+ * const redirectMiddleware = app.defineMiddleware((ctx) => {
+ * if (ctx.url.pathname.startsWith("/legacy/")) {
+ * return ctx.redirect("/modern");
+ * }
+ *
+ * // Otherwise call the next middleware
+ * return ctx.next();
+ * });
+ *
+ * // Again, register the middleware with the app.
+ * app.use(redirectMiddleware);
+ * ```
+ */
+export type MiddlewareFn = (
+ ctx: FreshContext,
+) => Response | Promise;
+
+/**
+ * A single middleware function, or an array of middleware functions. For
+ * further information, see {@link MiddlewareFn}.
+ */
+export type Middleware = MiddlewareFn | MiddlewareFn[];
+
+export function runMiddlewares(
+ middlewares: MiddlewareFn[][],
+ ctx: FreshContext,
+): Promise {
+ let fn = ctx.next;
+ let i = middlewares.length;
+ while (i--) {
+ const stack = middlewares[i];
+ let j = stack.length;
+ while (j--) {
+ const local = fn;
+ const next = stack[j];
+ fn = async () => {
+ ctx.next = local;
+ try {
+ return await next(ctx);
+ } catch (err) {
+ ctx.error = err;
+ throw err;
+ }
+ };
+ }
+ }
+ return fn();
+}
diff --git a/src/middlewares/mod_test.ts b/src/middlewares/mod_test.ts
new file mode 100644
index 00000000000..6176a6ff328
--- /dev/null
+++ b/src/middlewares/mod_test.ts
@@ -0,0 +1,136 @@
+import { runMiddlewares } from "./mod.ts";
+import { expect } from "@std/expect";
+import { serveMiddleware } from "../test_utils.ts";
+import type { MiddlewareFn } from "./mod.ts";
+
+Deno.test("runMiddleware", async () => {
+ const middlewares: MiddlewareFn<{ text: string }>[] = [
+ (ctx) => {
+ ctx.state.text = "A";
+ return ctx.next();
+ },
+ (ctx) => {
+ ctx.state.text += "B";
+ return ctx.next();
+ },
+ async (ctx) => {
+ const res = await ctx.next();
+ ctx.state.text += "C"; // This should not show up
+ return res;
+ },
+ (ctx) => {
+ return new Response(ctx.state.text);
+ },
+ ];
+
+ const server = serveMiddleware<{ text: string }>((ctx) =>
+ runMiddlewares([middlewares], ctx)
+ );
+
+ const res = await server.get("/");
+ expect(await res.text()).toEqual("AB");
+});
+
+Deno.test("runMiddleware - middlewares should only be called once", async () => {
+ const A: MiddlewareFn<{ count: number }> = (ctx) => {
+ if (ctx.state.count === undefined) {
+ ctx.state.count = 0;
+ } else {
+ ctx.state.count++;
+ }
+ return ctx.next();
+ };
+
+ const server = serveMiddleware<{ count: number }>((ctx) =>
+ runMiddlewares(
+ [[A, (ctx) => new Response(String(ctx.state.count))]],
+ ctx,
+ )
+ );
+
+ const res = await server.get("/");
+ expect(await res.text()).toEqual("0");
+});
+
+Deno.test("runMiddleware - runs multiple stacks", async () => {
+ type State = { text: string };
+ const A: MiddlewareFn = (ctx) => {
+ ctx.state.text += "A";
+ return ctx.next();
+ };
+ const B: MiddlewareFn = (ctx) => {
+ ctx.state.text += "B";
+ return ctx.next();
+ };
+ const C: MiddlewareFn = (ctx) => {
+ ctx.state.text += "C";
+ return ctx.next();
+ };
+ const D: MiddlewareFn = (ctx) => {
+ ctx.state.text += "D";
+ return ctx.next();
+ };
+
+ const server = serveMiddleware((ctx) => {
+ ctx.state.text = "";
+ return runMiddlewares(
+ [
+ [A, B],
+ [C, D, (ctx) => new Response(String(ctx.state.text))],
+ ],
+ ctx,
+ );
+ });
+
+ const res = await server.get("/");
+ expect(await res.text()).toEqual("ABCD");
+});
+
+Deno.test("runMiddleware - throws errors", async () => {
+ let thrownA: unknown = null;
+ let thrownB: unknown = null;
+ let thrownC: unknown = null;
+
+ const middlewares: MiddlewareFn<{ text: string }>[] = [
+ async (ctx) => {
+ try {
+ return await ctx.next();
+ } catch (err) {
+ thrownA = err;
+ throw err;
+ }
+ },
+ async (ctx) => {
+ try {
+ return await ctx.next();
+ } catch (err) {
+ thrownB = err;
+ throw err;
+ }
+ },
+ async (ctx) => {
+ try {
+ return await ctx.next();
+ } catch (err) {
+ thrownC = err;
+ throw err;
+ }
+ },
+ () => {
+ throw new Error("fail");
+ },
+ ];
+
+ const server = serveMiddleware<{ text: string }>((ctx) =>
+ runMiddlewares([middlewares], ctx)
+ );
+
+ try {
+ await server.get("/");
+ } catch {
+ // ignore
+ }
+ expect(thrownA).toBeInstanceOf(Error);
+ expect(thrownB).toBeInstanceOf(Error);
+ expect(thrownC).toBeInstanceOf(Error);
+});
diff --git a/src/middlewares/static_files.ts b/src/middlewares/static_files.ts
new file mode 100644
index 00000000000..63aa64a1f1f
--- /dev/null
+++ b/src/middlewares/static_files.ts
@@ -0,0 +1,77 @@
+import * as path from "@std/path";
+import { contentType as getContentType } from "@std/media-types/content-type";
+import type { MiddlewareFn } from "@fresh/core";
+import { ASSET_CACHE_BUST_KEY } from "../runtime/shared_internal.tsx";
+import { BUILD_ID } from "../runtime/build_id.ts";
+import { getBuildCache } from "../context.ts";
+
+/**
+ * Fresh middleware to enable file-system based routing.
+ * ```ts
+ * // Enable Fresh static file serving
+ * app.use(freshStaticFles());
+ * ```
+ */
+export function staticFiles(): MiddlewareFn {
+ return async function freshStaticFiles(ctx) {
+ const { req, url } = ctx;
+ const buildCache = getBuildCache(ctx);
+
+ // Fast path bail out
+ const file = await buildCache.readFile(url.pathname);
+ if (url.pathname === "/" || file === null) {
+ // Optimization: Prevent long responses for favicon.ico requests
+ if (url.pathname === "/favicon.ico") {
+ return new Response(null, { status: 404 });
+ }
+ return ctx.next();
+ }
+
+ if (req.method !== "GET" && req.method !== "HEAD") {
+ return new Response("Method Not Allowed", { status: 405 });
+ }
+
+ const cacheKey = url.searchParams.get(ASSET_CACHE_BUST_KEY);
+ if (cacheKey !== null && BUILD_ID !== cacheKey) {
+ url.searchParams.delete(ASSET_CACHE_BUST_KEY);
+ const location = url.pathname + url.search;
+ return new Response(null, {
+ status: 307,
+ headers: {
+ location,
+ },
+ });
+ }
+
+ const ext = path.extname(url.pathname);
+ const etag = file.hash;
+
+ const contentType = getContentType(ext);
+ const headers = new Headers({
+ "Content-Type": contentType ?? "text/plain",
+ vary: "If-None-Match",
+ });
+
+ if (cacheKey === null || ctx.config.mode === "development") {
+ headers.append(
+ "Cache-Control",
+ "no-cache, no-store, max-age=0, must-revalidate",
+ );
+ } else {
+ const ifNoneMatch = req.headers.get("If-None-Match");
+ if (
+ etag !== null &&
+ (ifNoneMatch === etag || ifNoneMatch === "W/" + etag)
+ ) {
+ return new Response(null, { status: 304, headers });
+ }
+ }
+
+ headers.set("Content-Length", String(file.size));
+ if (req.method === "HEAD") {
+ return new Response(null, { status: 200, headers });
+ }
+
+ return new Response(file.readable, { headers });
+ };
+}
diff --git a/src/middlewares/static_files_test.ts b/src/middlewares/static_files_test.ts
new file mode 100644
index 00000000000..4e91286b9cc
--- /dev/null
+++ b/src/middlewares/static_files_test.ts
@@ -0,0 +1,150 @@
+import { staticFiles } from "./static_files.ts";
+import { serveMiddleware } from "../test_utils.ts";
+import type { BuildCache, StaticFile } from "../build_cache.ts";
+import { expect } from "@std/expect";
+import { ASSET_CACHE_BUST_KEY } from "../runtime/shared_internal.tsx";
+import { BUILD_ID } from "../runtime/build_id.ts";
+
+class MockBuildCache implements BuildCache {
+ buildId = "MockId";
+ files = new Map();
+ hasSnapshot = true;
+
+ constructor(files: Record) {
+ const encoder = new TextEncoder();
+ for (const [pathname, info] of Object.entries(files)) {
+ const text = encoder.encode(info.content);
+
+ const normalized = pathname.startsWith("/") ? pathname : "/" + pathname;
+ this.files.set(normalized, {
+ hash: info.hash,
+ size: text.byteLength,
+ readable: text,
+ });
+ }
+ }
+
+ // deno-lint-ignore require-await
+ async readFile(pathname: string): Promise {
+ return this.files.get(pathname) ?? null;
+ }
+ getIslandChunkName(_islandName: string): string | null {
+ return null;
+ }
+}
+
+Deno.test("static files - 200", async () => {
+ const buildCache = new MockBuildCache({
+ "foo.css": { content: "body {}", hash: null },
+ });
+ const server = serveMiddleware(
+ staticFiles(),
+ { buildCache },
+ );
+
+ const res = await server.get("/foo.css");
+ const content = await res.text();
+ expect(res.status).toEqual(200);
+ expect(res.headers.get("Content-Type")).toEqual("text/css; charset=UTF-8");
+ expect(res.headers.get("Content-Length")).toEqual("7");
+ expect(res.headers.get("Cache-Control")).toEqual(
+ "no-cache, no-store, max-age=0, must-revalidate",
+ );
+ expect(content).toEqual("body {}");
+});
+
+Deno.test("static files - HEAD 200", async () => {
+ const buildCache = new MockBuildCache({
+ "foo.css": { content: "body {}", hash: null },
+ });
+ const server = serveMiddleware(
+ staticFiles(),
+ { buildCache },
+ );
+
+ const res = await server.head("/foo.css");
+ const content = await res.text();
+ expect(res.status).toEqual(200);
+ expect(res.headers.get("Content-Type")).toEqual("text/css; charset=UTF-8");
+ expect(res.headers.get("Content-Length")).toEqual("7");
+ expect(content).toEqual("");
+});
+
+Deno.test("static files - etag", async () => {
+ const buildCache = new MockBuildCache({
+ "foo.css": { content: "body {}", hash: "123" },
+ });
+ const server = serveMiddleware(
+ staticFiles(),
+ { buildCache },
+ );
+
+ const headers = new Headers();
+ headers.append("If-None-Match", "123");
+ const cacheUrl = `/foo.css?${ASSET_CACHE_BUST_KEY}=${BUILD_ID}`;
+ const res = await server.get(cacheUrl, { headers });
+ await res.body?.cancel();
+ expect(res.status).toEqual(304);
+
+ const headers2 = new Headers();
+ headers2.append("If-None-Match", "W/123");
+ const res2 = await server.get(cacheUrl, { headers });
+ await res2.body?.cancel();
+ expect(res2.status).toEqual(304);
+});
+
+Deno.test("static files - 404 on missing favicon.ico", async () => {
+ const buildCache = new MockBuildCache({});
+ const server = serveMiddleware(
+ staticFiles(),
+ { buildCache },
+ );
+ const res = await server.get("favicon.ico");
+ await res.body?.cancel();
+ expect(res.status).toEqual(404);
+});
+
+Deno.test("static files - 405 on wrong HTTP method", async () => {
+ const buildCache = new MockBuildCache({
+ "foo.css": { content: "body {}", hash: null },
+ });
+ const server = serveMiddleware(
+ staticFiles(),
+ { buildCache },
+ );
+
+ for (const method of ["post", "patch", "put", "delete"]) {
+ // deno-lint-ignore no-explicit-any
+ const res = await (server as any)[method]("/foo.css");
+ await res.body?.cancel();
+ expect(res.status).toEqual(405);
+ }
+});
+
+Deno.test("static files - disables caching in development", async () => {
+ const buildCache = new MockBuildCache({
+ "foo.css": { content: "body {}", hash: null },
+ });
+ const server = serveMiddleware(
+ staticFiles(),
+ {
+ buildCache,
+ config: {
+ basePath: "",
+ build: {
+ outDir: "",
+ },
+ mode: "development",
+ root: ".",
+ staticDir: "",
+ },
+ },
+ );
+
+ const res = await server.get("/foo.css");
+ await res.body?.cancel();
+ expect(res.status).toEqual(200);
+ expect(res.headers.get("Cache-Control")).toEqual(
+ "no-cache, no-store, max-age=0, must-revalidate",
+ );
+});
diff --git a/src/middlewares/trailing_slashes.ts b/src/middlewares/trailing_slashes.ts
new file mode 100644
index 00000000000..98a004f1c17
--- /dev/null
+++ b/src/middlewares/trailing_slashes.ts
@@ -0,0 +1,29 @@
+import type { MiddlewareFn } from "./mod.ts";
+
+/**
+ * Fresh middleware to force URLs to end with a slash or never end with one.
+ *
+ * ```ts
+ * // Always add trailing slash
+ * app.use(trailingSlashes("always"));
+ * // Never add trailing slashes to URLs and remove them if present
+ * app.use(trailingSlashes("never"));
+ * ```
+ */
+export function trailingSlashes
-