Add strict null checks to the codebase

.vscode/settings.json

@@ -2,14 +2,27 @@
   "editor.defaultFormatter": "esbenp.prettier-vscode",
   "cSpell.words": [
     "cfetch",
+    "clipboardy",
+    "cloudflared",
     "esbuild",
     "estree",
     "execa",
+    "extensionless",
     "iarna",
     "keyvalue",
     "middlewares",
     "Miniflare",
+    "outdir",
     "outfile",
-    "Positionals"
-  ]
+    "pgrep",
+    "PKCE",
+    "Positionals",
+    "undici",
+    "wasmvalue",
+    "weakmap",
+    "weakset",
+    "webassemblymemory",
+    "websockets"
+  ],
+  "cSpell.ignoreWords": ["yxxx"]
 }

packages/wrangler/pages/functions/filepath-routing.ts

@@ -52,7 +52,7 @@ export async function generateConfigFromFileTree({
             const declaration = node.declaration;
 
             // `export async function onRequest() {...}`
-            if (declaration.type === "FunctionDeclaration") {
+            if (declaration.type === "FunctionDeclaration" && declaration.id) {
               exportNames.push(declaration.id.name);
             }
 
@@ -155,12 +155,10 @@ export async function generateConfigFromFileTree({
 // more specific routes aren't occluded from matching due to
 // less specific routes appearing first in the route list.
 export function compareRoutes(a: string, b: string) {
-  function parseRoutePath(routePath: string) {
-    let [method, segmentedPath] = routePath.split(" ");
-    if (!segmentedPath) {
-      segmentedPath = method;
-      method = null;
-    }
+  function parseRoutePath(routePath: string): [string | null, string[]] {
+    const parts = routePath.split(" ", 2);
+    const segmentedPath = parts.pop() ?? "";
+    const method = parts.pop() ?? null;
 
     const segments = segmentedPath.slice(1).split("/").filter(Boolean);
     return [method, segments];
@@ -205,7 +203,9 @@ async function forEachFile<T>(
   const returnValues: T[] = [];
 
   while (searchPaths.length) {
-    const cwd = searchPaths.shift();
+    // The `searchPaths.length` check above ensures that `searchPaths.shift()` is defined
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const cwd = searchPaths.shift()!;
     const dir = await fs.readdir(cwd, { withFileTypes: true });
     for (const entry of dir) {
       const pathname = path.join(cwd, entry.name);

packages/wrangler/pages/functions/routes.ts

@@ -114,7 +114,7 @@ export function parseConfig(config: Config, baseDir: string) {
     });
   }
 
-  for (const [route, props] of Object.entries(config.routes)) {
+  for (const [route, props] of Object.entries(config.routes ?? {})) {
     let [_methods, routePath] = route.split(" ");
     if (!routePath) {
       routePath = _methods;

packages/wrangler/pages/functions/template-worker.ts

@@ -33,17 +33,16 @@ declare const routes: RouteHandler[];
 declare const __FALLBACK_SERVICE__: string;
 
 // expect an ASSETS fetcher binding pointing to the asset-server stage
-type Env = {
-  [name: string]: unknown;
-  ASSETS: { fetch(url: string, init: RequestInit): Promise<Response> };
+type FetchEnv = {
+  [name: string]: { fetch: typeof fetch };
+  ASSETS: { fetch: typeof fetch };
 };
 
 type WorkerContext = {
   waitUntil: (promise: Promise<unknown>) => void;
 };
 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars -- `env` can be used by __FALLBACK_SERVICE_FETCH__
-function* executeRequest(request: Request, env: Env) {
+function* executeRequest(request: Request, _env: FetchEnv) {
   const requestPath = new URL(request.url).pathname;
 
   // First, iterate through the routes (backwards) and execute "middlewares" on partial route matches
@@ -88,35 +87,21 @@ function* executeRequest(request: Request, env: Env) {
       break;
     }
   }
-
-  // Finally, yield to the fallback service (`env.ASSETS.fetch` in Pages' case)
-  return {
-    handler: () =>
-      __FALLBACK_SERVICE__
-        ? // @ts-expect-error expecting __FALLBACK_SERVICE__ to be the name of a service binding, so fetch should be defined
-          env[__FALLBACK_SERVICE__].fetch(request)
-        : fetch(request),
-    params: {} as Params,
-  };
 }
 
 export default {
-  async fetch(request: Request, env: Env, workerContext: WorkerContext) {
+  async fetch(request: Request, env: FetchEnv, workerContext: WorkerContext) {
     const handlerIterator = executeRequest(request, env);
     const data = {}; // arbitrary data the user can set between functions
     const next = async (input?: RequestInfo, init?: RequestInit) => {
       if (input !== undefined) {
         request = new Request(input, init);
       }
 
-      const { value } = handlerIterator.next();
-      if (value) {
-        const { handler, params } = value;
-        const context: EventContext<
-          unknown,
-          string,
-          Record<string, unknown>
-        > = {
+      const result = handlerIterator.next();
+      if (!result.done) {
+        const { handler, params } = result.value;
+        const context = {
           request: new Request(request.clone()),
           next,
           params,
@@ -132,6 +117,12 @@ export default {
           [101, 204, 205, 304].includes(response.status) ? null : response.body,
           response
         );
+      } else if (__FALLBACK_SERVICE__) {
+        // There are no more handlers so finish with the fallback service (`env.ASSETS.fetch` in Pages' case)
+        return env[__FALLBACK_SERVICE__].fetch(request);
+      } else {
+        // There was not fallback service so actually make the request to the origin.
+        return fetch(request);
       }
     };
 

packages/wrangler/src/__tests__/kv.test.ts

@@ -212,7 +212,7 @@ describe("wrangler", () => {
 
       it("should make multiple requests for paginated results", async () => {
         // Create a lot of mock namespaces, so that the fetch requests will be paginated
-        const KVNamespaces = [];
+        const KVNamespaces: { title: string; id: string }[] = [];
         for (let i = 0; i < 550; i++) {
           KVNamespaces.push({ title: "title-" + i, id: "id-" + i });
         }
@@ -335,8 +335,12 @@ describe("wrangler", () => {
             expect(namespaceId).toEqual(expectedNamespaceId);
             expect(key).toEqual(expectedKey);
             expect(body).toEqual(expectedValue);
-            expect(query.get("expiration")).toEqual(`${expiration}`);
-            expect(query.get("expiration_ttl")).toEqual(`${expirationTtl}`);
+            if (expiration) {
+              expect(query.get("expiration")).toEqual(`${expiration}`);
+            }
+            if (expirationTtl) {
+              expect(query.get("expiration_ttl")).toEqual(`${expirationTtl}`);
+            }
             return null;
           }
         );
@@ -681,7 +685,7 @@ describe("wrangler", () => {
             if (expectedKeys.length <= keysPerRequest) {
               return createFetchResult(expectedKeys);
             } else {
-              const start = parseInt(query.get("cursor")) || 0;
+              const start = parseInt(query.get("cursor") ?? "0") || 0;
               const end = start + keysPerRequest;
               const cursor = end < expectedKeys.length ? end : undefined;
               return createFetchResult(
@@ -778,7 +782,7 @@ describe("wrangler", () => {
 
       it("should make multiple requests for paginated results", async () => {
         // Create a lot of mock keys, so that the fetch requests will be paginated
-        const keys = [];
+        const keys: string[] = [];
         for (let i = 0; i < 550; i++) {
           keys.push("key-" + i);
         }

packages/wrangler/src/__tests__/mock-cfetch.ts

@@ -1,5 +1,5 @@
 import type { RequestInit } from "node-fetch";
-import type { URLSearchParams } from "node:url";
+import { URLSearchParams } from "node:url";
 import { pathToRegexp } from "path-to-regexp";
 import { CF_API_BASE_URL } from "../cfetch";
 import type { FetchResult } from "../cfetch";
@@ -9,8 +9,8 @@ import type { FetchResult } from "../cfetch";
  */
 export type MockHandler<ResponseType> = (
   uri: RegExpExecArray,
-  init?: RequestInit,
-  queryParams?: URLSearchParams
+  init: RequestInit,
+  queryParams: URLSearchParams
 ) => ResponseType;
 
 type RemoveMockFn = () => void;
@@ -32,7 +32,7 @@ const mocks: MockFetch<unknown>[] = [];
 export async function mockFetchInternal(
   resource: string,
   init: RequestInit = {},
-  queryParams?: URLSearchParams
+  queryParams: URLSearchParams = new URLSearchParams()
 ) {
   for (const { regexp, method, handler } of mocks) {
     const resourcePath = new URL(resource, CF_API_BASE_URL).pathname;

packages/wrangler/src/api/form_data.ts

@@ -23,7 +23,7 @@ export function toMimeType(type: CfModuleType): string {
   }
 }
 
-function toModule(module: CfModule, entryType?: CfModuleType): Blob {
+function toModule(module: CfModule, entryType: CfModuleType): Blob {
   const { type: moduleType, content } = module;
   const type = toMimeType(moduleType ?? entryType);
 

packages/wrangler/src/api/worker.ts

@@ -112,15 +112,15 @@ export interface CfWorkerInit {
   /**
    * The name of the worker.
    */
-  name: string | void;
+  name: string | undefined;
   /**
    * The entrypoint module.
    */
   main: CfModule;
   /**
    * The list of additional modules.
    */
-  modules: void | CfModule[];
+  modules: undefined | CfModule[];
   /**
    * All the bindings
    */
@@ -130,10 +130,10 @@ export interface CfWorkerInit {
     vars?: CfVars;
     services?: CfService[];
   };
-  migrations: void | CfDurableObjectMigrations;
-  compatibility_date: string | void;
-  compatibility_flags: void | string[];
-  usage_model: void | "bundled" | "unbound";
+  migrations: undefined | CfDurableObjectMigrations;
+  compatibility_date: string | undefined;
+  compatibility_flags: undefined | string[];
+  usage_model: undefined | "bundled" | "unbound";
 }
 
 /**

packages/wrangler/src/cfetch/internal.ts

@@ -1,5 +1,5 @@
-import fetch from "node-fetch";
-import type { RequestInit, HeadersInit } from "node-fetch";
+import fetch, { Headers } from "node-fetch";
+import type { RequestInit } from "node-fetch";
 import { getAPIToken, loginOrRefreshIfRequired } from "../user";
 
 export const CF_API_BASE_URL =
@@ -21,7 +21,7 @@ export async function fetchInternal<ResponseType>(
 ): Promise<ResponseType> {
   await requireLoggedIn();
   const apiToken = requireApiToken();
-  const headers = cloneHeaders(init.headers);
+  const headers = new Headers(init.headers);
   addAuthorizationHeader(headers, apiToken);
 
   const queryString = queryParams ? `?${queryParams.toString()}` : "";
@@ -55,11 +55,7 @@ function requireApiToken(): string {
   return apiToken;
 }
 
-function cloneHeaders(headers: HeadersInit): HeadersInit {
-  return { ...headers };
-}
-
-function addAuthorizationHeader(headers: HeadersInit, apiToken: string): void {
+function addAuthorizationHeader(headers: Headers, apiToken: string): void {
   if (headers["Authorization"]) {
     throw new Error(
       "The request already specifies an authorisation header - cannot add a new one."

packages/wrangler/src/config.ts

@@ -127,5 +127,5 @@ export type Config = {
   usage_model?: UsageModel; // inherited
   // top level
   build?: Build;
-  env?: { [envName: string]: void | Env };
+  env?: { [envName: string]: undefined | Env };
 };