wrangler 0.0.0-beta.6 → 0.0.0-bfbb0be

package/src/pages/build.tsx

@@ -0,0 +1,202 @@
+import { writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { logger } from "../logger";
+import { toUrlPath } from "../paths";
+import { isInPagesCI } from "./constants";
+import { buildPlugin } from "./functions/buildPlugin";
+import { buildWorker } from "./functions/buildWorker";
+import { generateConfigFromFileTree } from "./functions/filepath-routing";
+import { writeRoutesModule } from "./functions/routes";
+import { pagesBetaWarning, RUNNING_BUILDERS } from "./utils";
+import type { Config } from "./functions/routes";
+import type { ArgumentsCamelCase, Argv } from "yargs";
+
+type PagesBuildArgs = {
+  directory: string;
+  outfile: string;
+  "output-config-path"?: string;
+  minify: boolean;
+  sourcemap: boolean;
+  "fallback-service": string;
+  watch: boolean;
+  plugin: boolean;
+  "build-output-directory"?: string;
+  "node-compat": boolean;
+};
+
+export function Options(yargs: Argv): Argv<PagesBuildArgs> {
+  return yargs
+    .positional("directory", {
+      type: "string",
+      default: "functions",
+      description: "The directory of Pages Functions",
+    })
+    .options({
+      outfile: {
+        type: "string",
+        default: "_worker.js",
+        description: "The location of the output Worker script",
+      },
+      "output-config-path": {
+        type: "string",
+        description: "The location for the output config file",
+      },
+      minify: {
+        type: "boolean",
+        default: false,
+        description: "Minify the output Worker script",
+      },
+      sourcemap: {
+        type: "boolean",
+        default: false,
+        description: "Generate a sourcemap for the output Worker script",
+      },
+      "fallback-service": {
+        type: "string",
+        default: "ASSETS",
+        description:
+          "The service to fallback to at the end of the `next` chain. Setting to '' will fallback to the global `fetch`.",
+      },
+      watch: {
+        type: "boolean",
+        default: false,
+        description:
+          "Watch for changes to the functions and automatically rebuild the Worker script",
+      },
+      plugin: {
+        type: "boolean",
+        default: false,
+        description: "Build a plugin rather than a Worker script",
+      },
+      "build-output-directory": {
+        type: "string",
+        description: "The directory to output static assets to",
+      },
+      "node-compat": {
+        describe: "Enable node.js compatibility",
+        default: false,
+        type: "boolean",
+        hidden: true,
+      },
+    })
+    .epilogue(pagesBetaWarning);
+}
+
+export const Handler = async ({
+  directory,
+  outfile,
+  "output-config-path": outputConfigPath,
+  minify,
+  sourcemap,
+  fallbackService,
+  watch,
+  plugin,
+  "build-output-directory": buildOutputDirectory,
+  "node-compat": nodeCompat,
+}: ArgumentsCamelCase<PagesBuildArgs>) => {
+  if (!isInPagesCI) {
+    // Beta message for `wrangler pages <commands>` usage
+    logger.log(pagesBetaWarning);
+  }
+
+  if (nodeCompat) {
+    console.warn(
+      "Enabling node.js compatibility mode for builtins and globals. This is experimental and has serious tradeoffs. Please see https://github.com/ionic-team/rollup-plugin-node-polyfills/ for more details."
+    );
+  }
+
+  buildOutputDirectory ??= dirname(outfile);
+
+  await buildFunctions({
+    outfile,
+    outputConfigPath,
+    functionsDirectory: directory,
+    minify,
+    sourcemap,
+    fallbackService,
+    watch,
+    plugin,
+    buildOutputDirectory,
+    nodeCompat,
+  });
+};
+
+export async function buildFunctions({
+  outfile,
+  outputConfigPath,
+  functionsDirectory,
+  minify = false,
+  sourcemap = false,
+  fallbackService = "ASSETS",
+  watch = false,
+  onEnd,
+  plugin = false,
+  buildOutputDirectory,
+  nodeCompat,
+}: {
+  outfile: string;
+  outputConfigPath?: string;
+  functionsDirectory: string;
+  minify?: boolean;
+  sourcemap?: boolean;
+  fallbackService?: string;
+  watch?: boolean;
+  onEnd?: () => void;
+  plugin?: boolean;
+  buildOutputDirectory?: string;
+  nodeCompat?: boolean;
+}) {
+  RUNNING_BUILDERS.forEach(
+    (runningBuilder) => runningBuilder.stop && runningBuilder.stop()
+  );
+
+  const routesModule = join(tmpdir(), `./functionsRoutes-${Math.random()}.mjs`);
+  const baseURL = toUrlPath("/");
+
+  const config: Config = await generateConfigFromFileTree({
+    baseDir: functionsDirectory,
+    baseURL,
+  });
+
+  if (outputConfigPath) {
+    writeFileSync(
+      outputConfigPath,
+      JSON.stringify({ ...config, baseURL }, null, 2)
+    );
+  }
+
+  await writeRoutesModule({
+    config,
+    srcDir: functionsDirectory,
+    outfile: routesModule,
+  });
+
+  if (plugin) {
+    RUNNING_BUILDERS.push(
+      await buildPlugin({
+        routesModule,
+        outfile,
+        minify,
+        sourcemap,
+        watch,
+        nodeCompat,
+        onEnd,
+      })
+    );
+  } else {
+    RUNNING_BUILDERS.push(
+      await buildWorker({
+        routesModule,
+        outfile,
+        minify,
+        sourcemap,
+        fallbackService,
+        watch,
+        onEnd,
+        buildOutputDirectory,
+        nodeCompat,
+      })
+    );
+  }
+}

package/src/pages/constants.ts

@@ -0,0 +1,7 @@
+export const PAGES_CONFIG_CACHE_FILENAME = "pages.json";
+export const MAX_BUCKET_SIZE = 50 * 1024 * 1024;
+export const MAX_BUCKET_FILE_COUNT = 5000;
+export const BULK_UPLOAD_CONCURRENCY = 3;
+export const MAX_UPLOAD_ATTEMPTS = 5;
+export const SECONDS_TO_WAIT_FOR_PROXY = 5;
+export const isInPagesCI = !!process.env.CF_PAGES;

package/src/pages/deployments.tsx

@@ -0,0 +1,101 @@
+import { render, Text } from "ink";
+import SelectInput from "ink-select-input";
+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 { FatalError } from "../errors";
+import { requireAuth } from "../user";
+import { PAGES_CONFIG_CACHE_FILENAME } from "./constants";
+import { listProjects } from "./projects";
+import { pagesBetaWarning } from "./utils";
+import type { Deployment, PagesConfigCache } from "./types";
+import type { ArgumentsCamelCase, Argv } from "yargs";
+
+type ListArgs = {
+  "project-name"?: string;
+};
+
+export function ListOptions(yargs: Argv): Argv<ListArgs> {
+  return yargs
+    .options({
+      "project-name": {
+        type: "string",
+        description:
+          "The name of the project you would like to list deployments for",
+      },
+    })
+    .epilogue(pagesBetaWarning);
+}
+
+export async function ListHandler({
+  projectName,
+}: ArgumentsCamelCase<ListArgs>) {
+  const config = getConfigCache<PagesConfigCache>(PAGES_CONFIG_CACHE_FILENAME);
+  const accountId = await requireAuth(config);
+
+  projectName ??= config.project_name;
+
+  const isInteractive = process.stdin.isTTY;
+  if (!projectName && isInteractive) {
+    const projects = await listProjects({ accountId });
+    projectName = await new Promise((resolve) => {
+      const { unmount } = render(
+        <>
+          <Text>Select a project:</Text>
+          <SelectInput
+            items={projects.map((project) => ({
+              key: project.name,
+              label: project.name,
+              value: project,
+            }))}
+            onSelect={async (selected) => {
+              resolve(selected.value.name);
+              unmount();
+            }}
+          />
+        </>
+      );
+    });
+  }
+
+  if (!projectName) {
+    throw new FatalError("Must specify a project name.", 1);
+  }
+
+  const deployments: Array<Deployment> = await fetchResult(
+    `/accounts/${accountId}/pages/projects/${projectName}/deployments`
+  );
+
+  const titleCase = (word: string) =>
+    word.charAt(0).toUpperCase() + word.slice(1);
+
+  const shortSha = (sha: string) => sha.slice(0, 7);
+
+  const getStatus = (deployment: Deployment) => {
+    // Return a pretty time since timestamp if successful otherwise the status
+    if (deployment.latest_stage.status === `success`) {
+      return timeagoFormat(deployment.latest_stage.ended_on);
+    }
+    return titleCase(deployment.latest_stage.status);
+  };
+
+  const data = deployments.map((deployment) => {
+    return {
+      Environment: titleCase(deployment.environment),
+      Branch: deployment.deployment_trigger.metadata.branch,
+      Source: shortSha(deployment.deployment_trigger.metadata.commit_hash),
+      Deployment: deployment.url,
+      Status: getStatus(deployment),
+      // TODO: Use a url shortener
+      Build: `https://dash.cloudflare.com/${accountId}/pages/view/${deployment.project_name}/${deployment.id}`,
+    };
+  });
+
+  saveToConfigCache<PagesConfigCache>(PAGES_CONFIG_CACHE_FILENAME, {
+    account_id: accountId,
+  });
+
+  render(<Table data={data}></Table>, { patchConsole: false });
+}