wrangler 0.0.0-bf67bf2 → 0.0.0-bfbb0be

package/src/pages/functions/identifiers.ts

@@ -0,0 +1,78 @@
+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/src/pages/functions/routes.ts

@@ -0,0 +1,151 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { isValidIdentifier, normalizeIdentifier } from "./identifiers";
+import type { UrlPath } from "../../paths";
+
+export const HTTP_METHODS = [
+  "HEAD",
+  "OPTIONS",
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+] as const;
+export type HTTPMethod = typeof HTTP_METHODS[number];
+
+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/src/pages/index.tsx

@@ -0,0 +1,84 @@
+/* eslint-disable no-shadow */
+
+import * as Build from "./build";
+import * as Deployments from "./deployments";
+import * as Dev from "./dev";
+import * as Projects from "./projects";
+import * as Publish from "./publish";
+import * as Upload from "./upload";
+import { CLEANUP, pagesBetaWarning } from "./utils";
+import type { BuilderCallback } from "yargs";
+
+process.on("SIGINT", () => {
+  CLEANUP();
+  process.exit();
+});
+process.on("SIGTERM", () => {
+  CLEANUP();
+  process.exit();
+});
+
+export const pages: BuilderCallback<unknown, unknown> = (yargs) => {
+  return yargs
+    .command(
+      "dev [directory] [-- command..]",
+      "🧑‍💻 Develop your full-stack Pages application locally",
+      Dev.Options,
+      Dev.Handler
+    )
+    .command("functions", false, (yargs) =>
+      // we hide this command from help output because
+      // it's not meant to be used directly right now
+      {
+        return yargs.command(
+          "build [directory]",
+          "Compile a folder of Cloudflare Pages Functions into a single Worker",
+          Build.Options,
+          Build.Handler
+        );
+      }
+    )
+    .command("project", "⚡️ Interact with your Pages projects", (yargs) =>
+      yargs
+        .command(
+          "list",
+          "List your Cloudflare Pages projects",
+          Projects.ListOptions,
+          Projects.ListHandler
+        )
+        .command(
+          "create [project-name]",
+          "Create a new Cloudflare Pages project",
+          Projects.CreateOptions,
+          Projects.CreateHandler
+        )
+        .command("upload [directory]", false, Upload.Options, Upload.Handler)
+        .epilogue(pagesBetaWarning)
+    )
+    .command(
+      "deployment",
+      "🚀 Interact with the deployments of a project",
+      (yargs) =>
+        yargs
+          .command(
+            "list",
+            "List deployments in your Cloudflare Pages project",
+            Deployments.ListOptions,
+            Deployments.ListHandler
+          )
+          .command(
+            "create [directory]",
+            "🆙 Publish a directory of static assets as a Pages deployment",
+            Publish.Options,
+            Publish.Handler
+          )
+          .epilogue(pagesBetaWarning)
+    )
+    .command(
+      "publish [directory]",
+      "🆙 Publish a directory of static assets as a Pages deployment",
+      Publish.Options,
+      Publish.Handler
+    )
+    .epilogue(pagesBetaWarning);
+};

package/src/pages/projects.tsx

@@ -0,0 +1,157 @@
+import { execSync } from "node:child_process";
+import { render } from "ink";
+import Table from "ink-table";
+import React from "react";
+import { format as timeagoFormat } from "timeago.js";
+import { fetchResult } from "../cfetch";
+import { getConfigCache, saveToConfigCache } from "../config-cache";
+import { prompt } from "../dialogs";
+import { FatalError } from "../errors";
+import { logger } from "../logger";
+import { requireAuth } from "../user";
+import { PAGES_CONFIG_CACHE_FILENAME } from "./constants";
+import { pagesBetaWarning } from "./utils";
+import type { PagesConfigCache, Project } from "./types";
+import type { ArgumentsCamelCase, Argv } from "yargs";
+
+// Empty object, as per eslint
+type ListArgs = Record<string, never>;
+
+export function ListOptions(yargs: Argv): Argv<ListArgs> {
+  return yargs.epilogue(pagesBetaWarning);
+}
+
+export async function ListHandler() {
+  const config = getConfigCache<PagesConfigCache>(PAGES_CONFIG_CACHE_FILENAME);
+
+  const accountId = await requireAuth(config);
+
+  const projects: Array<Project> = await listProjects({ accountId });
+
+  const data = projects.map((project) => {
+    return {
+      "Project Name": project.name,
+      "Project Domains": `${project.domains.join(", ")}`,
+      "Git Provider": project.source ? "Yes" : "No",
+      "Last Modified": project.latest_deployment
+        ? timeagoFormat(project.latest_deployment.modified_on)
+        : timeagoFormat(project.created_on),
+    };
+  });
+
+  saveToConfigCache<PagesConfigCache>(PAGES_CONFIG_CACHE_FILENAME, {
+    account_id: accountId,
+  });
+
+  render(<Table data={data}></Table>, { patchConsole: false });
+}
+
+export const listProjects = async ({
+  accountId,
+}: {
+  accountId: string;
+}): Promise<Array<Project>> => {
+  const pageSize = 10;
+  let page = 1;
+  const results = [];
+  while (results.length % pageSize === 0) {
+    const json: Array<Project> = await fetchResult(
+      `/accounts/${accountId}/pages/projects`,
+      {},
+      new URLSearchParams({
+        per_page: pageSize.toString(),
+        page: page.toString(),
+      })
+    );
+    page++;
+    results.push(...json);
+    if (json.length < pageSize) {
+      break;
+    }
+  }
+  return results;
+};
+
+type CreateArgs = {
+  "project-name": string;
+  "production-branch"?: string;
+};
+
+export function CreateOptions(yargs: Argv): Argv<CreateArgs> {
+  return yargs
+    .positional("project-name", {
+      type: "string",
+      demandOption: true,
+      description: "The name of your Pages project",
+    })
+    .options({
+      "production-branch": {
+        type: "string",
+        description: "The name of the production branch of your project",
+      },
+    })
+    .epilogue(pagesBetaWarning);
+}
+
+export async function CreateHandler({
+  productionBranch,
+  projectName,
+}: ArgumentsCamelCase<CreateArgs>) {
+  const config = getConfigCache<PagesConfigCache>(PAGES_CONFIG_CACHE_FILENAME);
+  const accountId = await requireAuth(config);
+
+  const isInteractive = process.stdin.isTTY;
+  if (!projectName && isInteractive) {
+    projectName = await prompt("Enter the name of your new project:");
+  }
+
+  if (!projectName) {
+    throw new FatalError("Must specify a project name.", 1);
+  }
+
+  if (!productionBranch && isInteractive) {
+    let isGitDir = true;
+    try {
+      execSync(`git rev-parse --is-inside-work-tree`, {
+        stdio: "ignore",
+      });
+    } catch (err) {
+      isGitDir = false;
+    }
+
+    productionBranch = await prompt(
+      "Enter the production branch name:",
+      "text",
+      isGitDir
+        ? execSync(`git rev-parse --abbrev-ref HEAD`).toString().trim()
+        : "production"
+    );
+  }
+
+  if (!productionBranch) {
+    throw new FatalError("Must specify a production branch.", 1);
+  }
+
+  const { subdomain } = await fetchResult<Project>(
+    `/accounts/${accountId}/pages/projects`,
+    {
+      method: "POST",
+      body: JSON.stringify({
+        name: projectName,
+        production_branch: productionBranch,
+      }),
+    }
+  );
+
+  saveToConfigCache<PagesConfigCache>(PAGES_CONFIG_CACHE_FILENAME, {
+    account_id: accountId,
+    project_name: projectName,
+  });
+
+  logger.log(
+    `✨ Successfully created the '${projectName}' project. It will be available at https://${subdomain}/ once you create your first deployment.`
+  );
+  logger.log(
+    `To deploy a folder of assets, run 'wrangler pages publish [directory]'.`
+  );
+}