wrangler 0.0.0-e0d2f35 → 0.0.0-e144f63f

package/import_meta_url.js

@@ -1,3 +0,0 @@
-// as per https://github.com/evanw/esbuild/issues/1492
-// to make some libs work
-export const import_meta_url = require("url").pathToFileURL(__filename);

package/miniflare-config-stubs/package.empty.json

@@ -1 +0,0 @@
-{}

package/pages/functions/buildWorker.ts

@@ -1,62 +0,0 @@
-import path from "path";
-import { build } from "esbuild";
-
-type Options = {
-  routesModule: string;
-  outfile: string;
-  minify?: boolean;
-  sourcemap?: boolean;
-  fallbackService?: string;
-  watch?: boolean;
-  onEnd?: () => void;
-};
-
-export function buildWorker({
-  routesModule,
-  outfile = "bundle.js",
-  minify = false,
-  sourcemap = false,
-  fallbackService = "ASSETS",
-  watch = false,
-  onEnd = () => {},
-}: Options) {
-  return build({
-    entryPoints: [
-      path.resolve(__dirname, "../pages/functions/template-worker.ts"),
-    ],
-    inject: [routesModule],
-    bundle: true,
-    format: "esm",
-    target: "esnext",
-    outfile,
-    minify,
-    sourcemap,
-    watch,
-    allowOverwrite: true,
-    define: {
-      __FALLBACK_SERVICE__: JSON.stringify(fallbackService),
-    },
-    plugins: [
-      {
-        name: "wrangler notifier and monitor",
-        setup(pluginBuild) {
-          pluginBuild.onEnd((result) => {
-            if (result.errors.length > 0) {
-              console.error(
-                `${result.errors.length} error(s) and ${result.warnings.length} warning(s) when compiling Worker.`
-              );
-            } else if (result.warnings.length > 0) {
-              console.warn(
-                `${result.warnings.length} warning(s) when compiling Worker.`
-              );
-              onEnd();
-            } else {
-              console.log("Compiled Worker successfully.");
-              onEnd();
-            }
-          });
-        },
-      },
-    ],
-  });
-}

package/pages/functions/filepath-routing.test.ts

@@ -1,39 +0,0 @@
-import { compareRoutes } from "./filepath-routing";
-
-describe("compareRoutes()", () => {
-  test("routes / last", () => {
-    expect(compareRoutes("/", "/foo")).toBeGreaterThanOrEqual(1);
-    expect(compareRoutes("/", "/:foo")).toBeGreaterThanOrEqual(1);
-    expect(compareRoutes("/", "/:foo*")).toBeGreaterThanOrEqual(1);
-  });
-
-  test("routes with fewer segments come after those with more segments", () => {
-    expect(compareRoutes("/foo", "/foo/bar")).toBeGreaterThanOrEqual(1);
-    expect(compareRoutes("/foo", "/foo/bar/cat")).toBeGreaterThanOrEqual(1);
-  });
-
-  test("routes with wildcard segments come after those without", () => {
-    expect(compareRoutes("/:foo*", "/foo")).toBe(1);
-    expect(compareRoutes("/:foo*", "/:foo")).toBe(1);
-  });
-
-  test("routes with dynamic segments come after those without", () => {
-    expect(compareRoutes("/:foo", "/foo")).toBe(1);
-  });
-
-  test("routes with dynamic segments occuring earlier come after those with dynamic segments in later positions", () => {
-    expect(compareRoutes("/foo/:id/bar", "/foo/bar/:id")).toBe(1);
-  });
-
-  test("routes with no HTTP method come after those specifying a method", () => {
-    expect(compareRoutes("/foo", "GET /foo")).toBe(1);
-  });
-
-  test("two equal routes are sorted according to their original position in the list", () => {
-    expect(compareRoutes("GET /foo", "GET /foo")).toBe(0);
-  });
-
-  test("it returns -1 if the first argument should appear first in the list", () => {
-    expect(compareRoutes("GET /foo", "/foo")).toBe(-1);
-  });
-});

package/pages/functions/filepath-routing.ts

@@ -1,228 +0,0 @@
-import path from "path";
-import fs from "fs/promises";
-import { transform } from "esbuild";
-import * as acorn from "acorn";
-import * as acornWalk from "acorn-walk";
-import type { Config, RouteConfig } from "./routes";
-import type { ExportNamedDeclaration, Identifier } from "estree";
-
-type Arguments = {
-  baseDir: string;
-  baseURL: string;
-};
-
-export async function generateConfigFromFileTree({
-  baseDir,
-  baseURL,
-}: Arguments) {
-  let routeEntries: [string, RouteConfig][] = [];
-
-  if (!baseURL.startsWith("/")) {
-    baseURL = `/${baseURL}`;
-  }
-
-  if (baseURL.endsWith("/")) {
-    baseURL = baseURL.slice(0, -1);
-  }
-
-  await forEachFile(baseDir, async (filepath) => {
-    const ext = path.extname(filepath);
-    if (/^\.(mjs|js|ts|tsx|jsx)$/.test(ext)) {
-      // transform the code to ensure we're working with vanilla JS + ESM
-      const { code } = await transform(await fs.readFile(filepath, "utf-8"), {
-        loader: ext === ".ts" ? "ts" : "js",
-      });
-
-      // parse each file into an AST and search for module exports that match "onRequest" and friends
-      const ast = acorn.parse(code, {
-        ecmaVersion: "latest",
-        sourceType: "module",
-      });
-      acornWalk.simple(ast, {
-        ExportNamedDeclaration(_node: unknown) {
-          // This dynamic cast assumes that the AST generated by acornWalk will generate nodes that
-          // are compatible with the eslint AST nodes.
-          const node = _node as ExportNamedDeclaration;
-
-          // this is an array because multiple things can be exported from a single statement
-          // i.e. `export {foo, bar}` or `export const foo = "f", bar = "b"`
-          const exportNames: string[] = [];
-
-          if (node.declaration) {
-            const declaration = node.declaration;
-
-            // `export async function onRequest() {...}`
-            if (declaration.type === "FunctionDeclaration" && declaration.id) {
-              exportNames.push(declaration.id.name);
-            }
-
-            // `export const onRequestGet = () => {}, onRequestPost = () => {}`
-            if (declaration.type === "VariableDeclaration") {
-              exportNames.push(
-                ...declaration.declarations.map(
-                  (variableDeclarator) =>
-                    (variableDeclarator.id as unknown as Identifier).name
-                )
-              );
-            }
-          }
-
-          // `export {foo, bar}`
-          if (node.specifiers.length) {
-            exportNames.push(
-              ...node.specifiers.map(
-                (exportSpecifier) =>
-                  (exportSpecifier.exported as unknown as Identifier).name
-              )
-            );
-          }
-
-          for (const exportName of exportNames) {
-            const [match, method] =
-              exportName.match(
-                /^onRequest(Get|Post|Put|Patch|Delete|Options|Head)?$/
-              ) ?? [];
-
-            if (match) {
-              const basename = path.basename(filepath).slice(0, -ext.length);
-
-              const isIndexFile = basename === "index";
-              // TODO: deprecate _middleware_ in favor of _middleware
-              const isMiddlewareFile =
-                basename === "_middleware" || basename === "_middleware_";
-
-              let routePath = path
-                .relative(baseDir, filepath)
-                .slice(0, -ext.length);
-
-              if (isIndexFile || isMiddlewareFile) {
-                routePath = path.dirname(routePath);
-              }
-
-              if (routePath === ".") {
-                routePath = "";
-              }
-
-              routePath = `${baseURL}/${routePath}`;
-
-              routePath = routePath.replace(/\[\[(.+)]]/g, ":$1*"); // transform [[id]] => :id*
-              routePath = routePath.replace(/\[(.+)]/g, ":$1"); // transform [id] => :id
-
-              if (method) {
-                routePath = `${method.toUpperCase()} ${routePath}`;
-              }
-
-              routeEntries.push([
-                routePath,
-                {
-                  [isMiddlewareFile ? "middleware" : "module"]: [
-                    `${path.relative(baseDir, filepath)}:${exportName}`,
-                  ],
-                },
-              ]);
-            }
-          }
-        },
-      });
-    }
-  });
-
-  // Combine together any routes (index routes) which contain both a module and a middleware
-  routeEntries = routeEntries.reduce(
-    (acc: typeof routeEntries, [routePath, routeHandler]) => {
-      const existingRouteEntry = acc.find(
-        (routeEntry) => routeEntry[0] === routePath
-      );
-      if (existingRouteEntry !== undefined) {
-        existingRouteEntry[1] = {
-          ...existingRouteEntry[1],
-          ...routeHandler,
-        };
-      } else {
-        acc.push([routePath, routeHandler]);
-      }
-      return acc;
-    },
-    []
-  );
-
-  routeEntries.sort(([pathA], [pathB]) => compareRoutes(pathA, pathB));
-
-  return { routes: Object.fromEntries(routeEntries) } as Config;
-}
-
-// Ensure routes are produced in order of precedence so that
-// 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): [string | null, string[]] {
-    const parts = routePath.split(" ", 2);
-    // split() will guarantee at least one element.
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    const segmentedPath = parts.pop()!;
-    const method = parts.pop() ?? null;
-
-    const segments = segmentedPath.slice(1).split("/").filter(Boolean);
-    return [method, segments];
-  }
-
-  const [methodA, segmentsA] = parseRoutePath(a);
-  const [methodB, segmentsB] = parseRoutePath(b);
-
-  // sort routes with fewer segments after those with more segments
-  if (segmentsA.length !== segmentsB.length) {
-    return segmentsB.length - segmentsA.length;
-  }
-
-  for (let i = 0; i < segmentsA.length; i++) {
-    const isWildcardA = segmentsA[i].includes("*");
-    const isWildcardB = segmentsB[i].includes("*");
-    const isParamA = segmentsA[i].includes(":");
-    const isParamB = segmentsB[i].includes(":");
-
-    // sort wildcard segments after non-wildcard segments
-    if (isWildcardA && !isWildcardB) return 1;
-    if (!isWildcardA && isWildcardB) return -1;
-
-    // sort dynamic param segments after non-param segments
-    if (isParamA && !isParamB) return 1;
-    if (!isParamA && isParamB) return -1;
-  }
-
-  // sort routes that specify an HTTP before those that don't
-  if (methodA && !methodB) return -1;
-  if (!methodA && methodB) return 1;
-
-  // all else equal, just sort them lexicographically
-  return a.localeCompare(b);
-}
-
-async function forEachFile<T>(
-  baseDir: string,
-  fn: (filepath: string) => T | Promise<T>
-) {
-  const searchPaths = [baseDir];
-  const returnValues: T[] = [];
-
-  while (isNotEmpty(searchPaths)) {
-    const cwd = searchPaths.shift();
-    const dir = await fs.readdir(cwd, { withFileTypes: true });
-    for (const entry of dir) {
-      const pathname = path.join(cwd, entry.name);
-      if (entry.isDirectory()) {
-        searchPaths.push(pathname);
-      } else if (entry.isFile()) {
-        returnValues.push(await fn(pathname));
-      }
-    }
-  }
-
-  return returnValues;
-}
-
-interface NonEmptyArray<T> extends Array<T> {
-  shift(): T;
-}
-function isNotEmpty<T>(array: T[]): array is NonEmptyArray<T> {
-  return array.length > 0;
-}

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,158 +0,0 @@
-import path from "path";
-import fs from "fs/promises";
-import { isValidIdentifier, normalizeIdentifier } from "./identifiers";
-
-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: string;
-  methods: HTTPMethod[];
-  modules: string[];
-  middlewares: string[];
-}>;
-
-export type Config = {
-  routes?: RoutesConfig;
-  schedules?: unknown;
-};
-
-export type RoutesConfig = {
-  [route: string]: RouteConfig;
-};
-
-export type RouteConfig = {
-  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 [route, props] of Object.entries(config.routes ?? {})) {
-    let [_methods, routePath] = route.split(" ");
-    if (!routePath) {
-      routePath = _methods;
-      _methods = "";
-    }
-
-    routes.push({
-      routePath,
-      methods: _methods.split("|").filter(isHTTPMethod),
-      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}",
-      methods: ${JSON.stringify(route.methods)},
-      middlewares: [${route.middlewares.join(", ")}],
-      modules: [${route.modules.join(", ")}],
-    },`
-    )
-    .join("\n")}
-  ]`;
-}