wrangler 0.0.0-e492c10 → 0.0.0-e4bb5f36

package/pages/functions/identifiers.ts

@@ -1,78 +0,0 @@
-export const RESERVED_KEYWORDS = [
-  "do",
-  "if",
-  "in",
-  "for",
-  "let",
-  "new",
-  "try",
-  "var",
-  "case",
-  "else",
-  "enum",
-  "eval",
-  "null",
-  "this",
-  "true",
-  "void",
-  "with",
-  "await",
-  "break",
-  "catch",
-  "class",
-  "const",
-  "false",
-  "super",
-  "throw",
-  "while",
-  "yield",
-  "delete",
-  "export",
-  "import",
-  "public",
-  "return",
-  "static",
-  "switch",
-  "typeof",
-  "default",
-  "extends",
-  "finally",
-  "package",
-  "private",
-  "continue",
-  "debugger",
-  "function",
-  "arguments",
-  "interface",
-  "protected",
-  "implements",
-  "instanceof",
-  "NaN",
-  "Infinity",
-  "undefined",
-];
-
-export const reservedKeywordRegex = new RegExp(
-  `^${RESERVED_KEYWORDS.join("|")}$`
-);
-
-export const identifierStartRegex = /[$_\p{ID_Start}]/u;
-
-export const identifierPartRegex = /[$_\u200C\u200D\p{ID_Continue}]/u;
-
-export const identifierNameRegex =
-  /^(?:[$_\p{ID_Start}])(?:[$_\u200C\u200D\p{ID_Continue}])*$/u;
-
-export const validIdentifierRegex = new RegExp(
-  `(?!(${reservedKeywordRegex.source})$)${identifierNameRegex.source}`,
-  "u"
-);
-
-export const isValidIdentifier = (identifier: string) =>
-  validIdentifierRegex.test(identifier);
-
-export const normalizeIdentifier = (identifier: string) =>
-  identifier.replace(
-    /(?:^[^$_\p{ID_Start}])|[^$_\u200C\u200D\p{ID_Continue}]/gu,
-    "_"
-  );

package/pages/functions/routes.ts

@@ -1,156 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { isValidIdentifier, normalizeIdentifier } from "./identifiers";
-import type { UrlPath } from "../../src/paths";
-
-export const HTTP_METHODS = [
-  "HEAD",
-  "OPTIONS",
-  "GET",
-  "POST",
-  "PUT",
-  "PATCH",
-  "DELETE",
-] as const;
-export type HTTPMethod = typeof HTTP_METHODS[number];
-export function isHTTPMethod(
-  maybeHTTPMethod: string
-): maybeHTTPMethod is HTTPMethod {
-  return (HTTP_METHODS as readonly string[]).includes(maybeHTTPMethod);
-}
-
-export type RoutesCollection = Array<{
-  routePath: UrlPath;
-  mountPath: UrlPath;
-  method?: HTTPMethod;
-  modules: string[];
-  middlewares: string[];
-}>;
-
-export type Config = {
-  routes?: RouteConfig[];
-  schedules?: unknown;
-};
-
-export type RouteConfig = {
-  routePath: UrlPath;
-  mountPath: UrlPath;
-  method?: HTTPMethod;
-  middleware?: string | string[];
-  module?: string | string[];
-};
-
-type ImportMap = Map<
-  string,
-  {
-    filepath: string;
-    name: string;
-    identifier: string;
-  }
->;
-
-type Arguments = {
-  config: Config;
-  outfile: string;
-  srcDir: string;
-};
-
-export async function writeRoutesModule({
-  config,
-  srcDir,
-  outfile = "_routes.js",
-}: Arguments) {
-  const { importMap, routes } = parseConfig(config, srcDir);
-  const routesModule = generateRoutesModule(importMap, routes);
-
-  await fs.writeFile(outfile, routesModule);
-
-  return outfile;
-}
-
-export function parseConfig(config: Config, baseDir: string) {
-  const routes: RoutesCollection = [];
-  const importMap: ImportMap = new Map();
-  const identifierCount = new Map<string, number>(); // to keep track of identifier collisions
-
-  function parseModuleIdentifiers(paths: string | string[] | undefined) {
-    if (typeof paths === "undefined") {
-      paths = [];
-    }
-
-    if (typeof paths === "string") {
-      paths = [paths];
-    }
-
-    return paths.map((modulePath) => {
-      const [filepath, name = "default"] = modulePath.split(":");
-      let { identifier } = importMap.get(modulePath) ?? {};
-
-      const resolvedPath = path.resolve(baseDir, filepath);
-
-      // ensure the filepath isn't attempting to resolve to anything outside of the project
-      if (path.relative(baseDir, resolvedPath).startsWith("..")) {
-        throw new Error(`Invalid module path "${filepath}"`);
-      }
-
-      // ensure the module name (if provided) is a valid identifier to guard against injection attacks
-      if (name !== "default" && !isValidIdentifier(name)) {
-        throw new Error(`Invalid module identifier "${name}"`);
-      }
-
-      if (!identifier) {
-        identifier = normalizeIdentifier(`__${filepath}_${name}`);
-
-        let count = identifierCount.get(identifier) ?? 0;
-        identifierCount.set(identifier, ++count);
-
-        if (count > 1) {
-          identifier += `_${count}`;
-        }
-
-        importMap.set(modulePath, { filepath: resolvedPath, name, identifier });
-      }
-
-      return identifier;
-    });
-  }
-
-  for (const { routePath, mountPath, method, ...props } of config.routes ??
-    []) {
-    routes.push({
-      routePath,
-      mountPath,
-      method,
-      middlewares: parseModuleIdentifiers(props.middleware),
-      modules: parseModuleIdentifiers(props.module),
-    });
-  }
-
-  return { routes, importMap };
-}
-
-export function generateRoutesModule(
-  importMap: ImportMap,
-  routes: RoutesCollection
-) {
-  return `${[...importMap.values()]
-    .map(
-      ({ filepath, name, identifier }) =>
-        `import { ${name} as ${identifier} } from ${JSON.stringify(filepath)}`
-    )
-    .join("\n")}
-
-export const routes = [
-  ${routes
-    .map(
-      (route) => `  {
-      routePath: "${route.routePath}",
-      mountPath: "${route.mountPath}",
-      method: "${route.method}",
-      middlewares: [${route.middlewares.join(", ")}],
-      modules: [${route.modules.join(", ")}],
-    },`
-    )
-    .join("\n")}
-  ]`;
-}

package/pages/functions/template-plugin.ts

@@ -1,146 +0,0 @@
-import { match } from "path-to-regexp";
-import type { HTTPMethod } from "./routes";
-
-/* TODO: Grab these from @cloudflare/workers-types instead */
-type Params<P extends string = string> = Record<P, string | string[]>;
-
-type EventContext<Env, P extends string, Data> = {
-  request: Request;
-  functionPath: string;
-  waitUntil: (promise: Promise<unknown>) => void;
-  next: (input?: Request | string, init?: RequestInit) => Promise<Response>;
-  env: Env & { ASSETS: { fetch: typeof fetch } };
-  params: Params<P>;
-  data: Data;
-};
-
-type EventPluginContext<Env, P extends string, Data, PluginArgs> = {
-  request: Request;
-  functionPath: string;
-  waitUntil: (promise: Promise<unknown>) => void;
-  next: (input?: Request | string, init?: RequestInit) => Promise<Response>;
-  env: Env & { ASSETS: { fetch: typeof fetch } };
-  params: Params<P>;
-  data: Data;
-  pluginArgs: PluginArgs;
-};
-
-declare type PagesFunction<
-  Env = unknown,
-  P extends string = string,
-  Data extends Record<string, unknown> = Record<string, unknown>
-> = (context: EventContext<Env, P, Data>) => Response | Promise<Response>;
-
-declare type PagesPluginFunction<
-  Env = unknown,
-  P extends string = string,
-  Data extends Record<string, unknown> = Record<string, unknown>,
-  PluginArgs = unknown
-> = (
-  context: EventPluginContext<Env, P, Data, PluginArgs>
-) => Response | Promise<Response>;
-/* end @cloudflare/workers-types */
-
-type RouteHandler = {
-  routePath: string;
-  mountPath: string;
-  method?: HTTPMethod;
-  modules: PagesFunction[];
-  middlewares: PagesFunction[];
-};
-
-// inject `routes` via ESBuild
-declare const routes: RouteHandler[];
-
-function* executeRequest(request: Request, relativePathname: string) {
-  // First, iterate through the routes (backwards) and execute "middlewares" on partial route matches
-  for (const route of [...routes].reverse()) {
-    if (route.method && route.method !== request.method) {
-      continue;
-    }
-
-    const routeMatcher = match(route.routePath, { end: false });
-    const mountMatcher = match(route.mountPath, { end: false });
-    const matchResult = routeMatcher(relativePathname);
-    const mountMatchResult = mountMatcher(relativePathname);
-    if (matchResult && mountMatchResult) {
-      for (const handler of route.middlewares.flat()) {
-        yield {
-          handler,
-          params: matchResult.params as Params,
-          path: mountMatchResult.path,
-        };
-      }
-    }
-  }
-
-  // Then look for the first exact route match and execute its "modules"
-  for (const route of routes) {
-    if (route.method && route.method !== request.method) {
-      continue;
-    }
-
-    const routeMatcher = match(route.routePath, { end: true });
-    const mountMatcher = match(route.mountPath, { end: false });
-    const matchResult = routeMatcher(relativePathname);
-    const mountMatchResult = mountMatcher(relativePathname);
-    if (matchResult && mountMatchResult && route.modules.length) {
-      for (const handler of route.modules.flat()) {
-        yield {
-          handler,
-          params: matchResult.params as Params,
-          path: matchResult.path,
-        };
-      }
-      break;
-    }
-  }
-}
-
-export default function (pluginArgs) {
-  const onRequest: PagesPluginFunction = async (workerContext) => {
-    let { request } = workerContext;
-    const { env, next, data } = workerContext;
-
-    const url = new URL(request.url);
-    const relativePathname =
-      url.pathname.split(workerContext.functionPath)[1] || "/";
-
-    const handlerIterator = executeRequest(request, relativePathname);
-    const pluginNext = async (input?: RequestInfo, init?: RequestInit) => {
-      if (input !== undefined) {
-        request = new Request(input, init);
-      }
-
-      const result = handlerIterator.next();
-      // Note we can't use `!result.done` because this doesn't narrow to the correct type
-      if (result.done === false) {
-        const { handler, params, path } = result.value;
-        const context = {
-          request,
-          functionPath: workerContext.functionPath + path,
-          next: pluginNext,
-          params,
-          data,
-          pluginArgs,
-          env,
-          waitUntil: workerContext.waitUntil.bind(workerContext),
-        };
-
-        const response = await handler(context);
-
-        // https://fetch.spec.whatwg.org/#null-body-status
-        return new Response(
-          [101, 204, 205, 304].includes(response.status) ? null : response.body,
-          { ...response, headers: new Headers(response.headers) }
-        );
-      } else {
-        return next();
-      }
-    };
-
-    return pluginNext();
-  };
-
-  return onRequest;
-}

package/pages/functions/template-worker.ts

@@ -1,143 +0,0 @@
-import { match } from "path-to-regexp";
-import type { HTTPMethod } from "./routes";
-
-/* TODO: Grab these from @cloudflare/workers-types instead */
-type Params<P extends string = string> = Record<P, string | string[]>;
-
-type EventContext<Env, P extends string, Data> = {
-  request: Request;
-  functionPath: string;
-  waitUntil: (promise: Promise<unknown>) => void;
-  next: (input?: Request | string, init?: RequestInit) => Promise<Response>;
-  env: Env & { ASSETS: { fetch: typeof fetch } };
-  params: Params<P>;
-  data: Data;
-};
-
-declare type PagesFunction<
-  Env = unknown,
-  P extends string = string,
-  Data extends Record<string, unknown> = Record<string, unknown>
-> = (context: EventContext<Env, P, Data>) => Response | Promise<Response>;
-/* end @cloudflare/workers-types */
-
-type RouteHandler = {
-  routePath: string;
-  mountPath: string;
-  method?: HTTPMethod;
-  modules: PagesFunction[];
-  middlewares: PagesFunction[];
-};
-
-// inject `routes` via ESBuild
-declare const routes: RouteHandler[];
-// define `__FALLBACK_SERVICE__` via ESBuild
-declare const __FALLBACK_SERVICE__: string;
-
-// expect an ASSETS fetcher binding pointing to the asset-server stage
-type FetchEnv = {
-  [name: string]: { fetch: typeof fetch };
-  ASSETS: { fetch: typeof fetch };
-};
-
-type WorkerContext = {
-  waitUntil: (promise: Promise<unknown>) => void;
-};
-
-function* executeRequest(request: Request) {
-  const requestPath = new URL(request.url).pathname;
-
-  // First, iterate through the routes (backwards) and execute "middlewares" on partial route matches
-  for (const route of [...routes].reverse()) {
-    if (route.method && route.method !== request.method) {
-      continue;
-    }
-
-    const routeMatcher = match(route.routePath, { end: false });
-    const mountMatcher = match(route.mountPath, { end: false });
-    const matchResult = routeMatcher(requestPath);
-    const mountMatchResult = mountMatcher(requestPath);
-    if (matchResult && mountMatchResult) {
-      for (const handler of route.middlewares.flat()) {
-        yield {
-          handler,
-          params: matchResult.params as Params,
-          path: mountMatchResult.path,
-        };
-      }
-    }
-  }
-
-  // Then look for the first exact route match and execute its "modules"
-  for (const route of routes) {
-    if (route.method && route.method !== request.method) {
-      continue;
-    }
-
-    const routeMatcher = match(route.routePath, { end: true });
-    const mountMatcher = match(route.mountPath, { end: false });
-    const matchResult = routeMatcher(requestPath);
-    const mountMatchResult = mountMatcher(requestPath);
-    if (matchResult && mountMatchResult && route.modules.length) {
-      for (const handler of route.modules.flat()) {
-        yield {
-          handler,
-          params: matchResult.params as Params,
-          path: matchResult.path,
-        };
-      }
-      break;
-    }
-  }
-}
-
-export default {
-  async fetch(request: Request, env: FetchEnv, workerContext: WorkerContext) {
-    const handlerIterator = executeRequest(request);
-    const data = {}; // arbitrary data the user can set between functions
-    const next = async (input?: RequestInfo, init?: RequestInit) => {
-      if (input !== undefined) {
-        let url = input;
-        if (typeof input === "string") {
-          url = new URL(input, request.url).toString();
-        }
-        request = new Request(url, init);
-      }
-
-      const result = handlerIterator.next();
-      // Note we can't use `!result.done` because this doesn't narrow to the correct type
-      if (result.done === false) {
-        const { handler, params, path } = result.value;
-        const context = {
-          request: new Request(request.clone()),
-          functionPath: path,
-          next,
-          params,
-          data,
-          env,
-          waitUntil: workerContext.waitUntil.bind(workerContext),
-        };
-
-        const response = await handler(context);
-
-        // https://fetch.spec.whatwg.org/#null-body-status
-        return new Response(
-          [101, 204, 205, 304].includes(response.status) ? null : response.body,
-          { ...response, headers: new Headers(response.headers) }
-        );
-      } 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);
-      }
-    };
-
-    try {
-      return next();
-    } catch (err) {
-      return new Response("Internal Error", { status: 500 });
-    }
-  },
-};

package/src/__tests__/config-cache.test.ts

@@ -1,36 +0,0 @@
-import { getConfigCache, saveToConfigCache } from "../config-cache";
-import { runInTempDir } from "./helpers/run-in-tmp";
-
-interface PagesConfigCache {
-  account_id: string;
-  pages_project_name: string;
-}
-
-describe("config cache", () => {
-  runInTempDir();
-
-  const pagesConfigCacheFilename = "pages-config-cache.json";
-
-  it("should return an empty config if no file exists", () => {
-    expect(
-      getConfigCache<PagesConfigCache>(pagesConfigCacheFilename)
-    ).toMatchInlineSnapshot(`Object {}`);
-  });
-
-  it("should read and write values without overriding old ones", () => {
-    saveToConfigCache<PagesConfigCache>(pagesConfigCacheFilename, {
-      account_id: "some-account-id",
-      pages_project_name: "foo",
-    });
-    expect(
-      getConfigCache<PagesConfigCache>(pagesConfigCacheFilename).account_id
-    ).toEqual("some-account-id");
-
-    saveToConfigCache<PagesConfigCache>(pagesConfigCacheFilename, {
-      pages_project_name: "bar",
-    });
-    expect(
-      getConfigCache<PagesConfigCache>(pagesConfigCacheFilename).account_id
-    ).toEqual("some-account-id");
-  });
-});