wrangler 0.0.0-e2f9bb2 → 0.0.0-e322475

package/src/durable.ts

@@ -0,0 +1,102 @@
+import assert from "node:assert";
+import { fetchResult } from "./cfetch";
+import { logger } from "./logger";
+import type { Config } from "./config";
+import type { CfWorkerInit } from "./worker";
+
+/**
+ * For a given Worker + migrations config, figure out which migrations
+ * to upload based on the current migration tag of the deployed Worker.
+ */
+export async function getMigrationsToUpload(
+  scriptName: string,
+  props: {
+    accountId: string | undefined;
+    config: Config;
+    legacyEnv: boolean | undefined;
+    env: string | undefined;
+  }
+): Promise<CfWorkerInit["migrations"]> {
+  const { config, accountId } = props;
+
+  assert(accountId, "Missing accountId");
+  // if config.migrations
+  let migrations;
+  if (config.migrations.length > 0) {
+    // get current migration tag
+    type ScriptData = { id: string; migration_tag?: string };
+    let script: ScriptData | undefined;
+    if (!props.legacyEnv) {
+      try {
+        if (props.env) {
+          const scriptData = await fetchResult<{
+            script: ScriptData;
+          }>(
+            `/accounts/${accountId}/workers/services/${scriptName}/environments/${props.env}`
+          );
+          script = scriptData.script;
+        } else {
+          const scriptData = await fetchResult<{
+            default_environment: {
+              script: ScriptData;
+            };
+          }>(`/accounts/${accountId}/workers/services/${scriptName}`);
+          script = scriptData.default_environment.script;
+        }
+      } catch (err) {
+        if (
+          ![
+            10090, // corresponds to workers.api.error.service_not_found, so the script wasn't previously published at all
+            10092, // workers.api.error.environment_not_found, so the script wasn't published to this environment yet
+          ].includes((err as { code: number }).code)
+        ) {
+          throw err;
+        }
+        // else it's a 404, no script found, and we can proceed
+      }
+    } else {
+      const scripts = await fetchResult<ScriptData[]>(
+        `/accounts/${accountId}/workers/scripts`
+      );
+      script = scripts.find(({ id }) => id === scriptName);
+    }
+
+    if (script?.migration_tag) {
+      // was already published once
+      const scriptMigrationTag = script.migration_tag;
+      const foundIndex = config.migrations.findIndex(
+        (migration) => migration.tag === scriptMigrationTag
+      );
+      if (foundIndex === -1) {
+        logger.warn(
+          `The published script ${scriptName} has a migration tag "${script.migration_tag}, which was not found in wrangler.toml. You may have already deleted it. Applying all available migrations to the script...`
+        );
+        migrations = {
+          old_tag: script.migration_tag,
+          new_tag: config.migrations[config.migrations.length - 1].tag,
+          steps: config.migrations.map(({ tag: _tag, ...rest }) => rest),
+        };
+      } else {
+        if (foundIndex !== config.migrations.length - 1) {
+          // there are new migrations to send up
+          migrations = {
+            old_tag: script.migration_tag,
+            new_tag: config.migrations[config.migrations.length - 1].tag,
+            steps: config.migrations
+              .slice(foundIndex + 1)
+              .map(({ tag: _tag, ...rest }) => rest),
+          };
+        }
+        // else, we're up to date, no migrations to send
+      }
+    } else {
+      // first time publishing durable objects to this script,
+      // so we send all the migrations
+      migrations = {
+        new_tag: config.migrations[config.migrations.length - 1].tag,
+        steps: config.migrations.map(({ tag: _tag, ...rest }) => rest),
+      };
+    }
+  }
+  return migrations;
+}

package/src/entry.ts

@@ -1,5 +1,5 @@
 import assert from "node:assert";
-import { existsSync } from "node:fs";
+import { existsSync, statSync } from "node:fs";
 import path from "node:path";
 import * as esbuild from "esbuild";
 import { execaCommand } from "execa";
@@ -19,7 +19,11 @@ export type Entry = { file: string; directory: string; format: CfScriptFormat };
  * Compute the entry-point for the Worker.
  */
 export async function getEntry(
-  args: { script?: string; format?: CfScriptFormat | undefined },
+  args: {
+    script?: string;
+    format?: CfScriptFormat | undefined;
+    assets?: string | undefined;
+  },
   config: Config,
   command: "dev" | "publish"
 ): Promise<Entry> {
@@ -35,6 +39,8 @@ export async function getEntry(
         ? path.resolve(config.site?.["entry-point"])
         : // site.entry-point could be a directory
           path.resolve(config.site?.["entry-point"], "index.js");
+    } else if (args.assets) {
+      file = path.resolve(__dirname, "../templates/no-op-worker.js");
     } else {
       throw new Error(
         `Missing entry-point: The entry-point should be specified via the command line (e.g. \`wrangler ${command} path/to/script\`) or the \`main\` config field.`
@@ -45,11 +51,16 @@ export async function getEntry(
     file = path.resolve(directory, config.main);
   }
 
-  await runCustomBuild(file, config.build);
+  const relativeFile = path.relative(directory, file) || ".";
+  await runCustomBuild(file, relativeFile, config.build);
 
   if (fileExists(file) === false) {
     throw new Error(
-      `Could not resolve "${path.relative(process.cwd(), file)}".`
+      getMissingEntryPointMessage(
+        `The entry-point file at "${relativeFile}" was not found.`,
+        file,
+        relativeFile
+      )
     );
   }
   const format = await guessWorkerFormat(
@@ -90,7 +101,8 @@ export async function getEntry(
 }
 
 export async function runCustomBuild(
-  expectedEntry: string,
+  expectedEntryAbsolute: string,
+  expectedEntryRelative: string,
   build: Config["build"]
 ) {
   if (build?.command) {
@@ -105,12 +117,14 @@ export async function runCustomBuild(
       ...(build.cwd && { cwd: build.cwd }),
     });
 
-    if (fileExists(expectedEntry) === false) {
+    if (fileExists(expectedEntryAbsolute) === false) {
       throw new Error(
-        `Could not resolve "${path.relative(
-          process.cwd(),
-          expectedEntry
-        )}" after running custom build: ${build.command}`
+        getMissingEntryPointMessage(
+          `The expected output file at "${expectedEntryRelative}" was not found after running custom build: ${build.command}.\n` +
+            "The `main` property in wrangler.toml should point to the file generated by the custom build.",
+          expectedEntryAbsolute,
+          expectedEntryRelative
+        )
       );
     }
   }
@@ -265,3 +279,50 @@ function generateAddScriptNameExamples(
     })
     .join("\n");
 }
+
+/**
+ * Generate an appropriate message for when the entry-point is missing.
+ *
+ * To be more helpful to developers, we check whether there is a suitable file
+ * nearby to the expected file path.
+ */
+function getMissingEntryPointMessage(
+  message: string,
+  absoluteEntryPointPath: string,
+  relativeEntryPointPath: string
+): string {
+  if (
+    existsSync(absoluteEntryPointPath) &&
+    statSync(absoluteEntryPointPath).isDirectory()
+  ) {
+    // The expected entry-point is a directory, so offer further guidance.
+    message += `\nThe provided entry-point path, "${relativeEntryPointPath}", points to a directory, rather than a file.\n`;
+
+    // Perhaps we can even guess what the correct path should be...
+    const possiblePaths: string[] = [];
+    for (const basenamePath of [
+      "worker",
+      "dist/worker",
+      "index",
+      "dist/index",
+    ]) {
+      for (const extension of [".ts", ".tsx", ".js", ".jsx"]) {
+        const filePath = basenamePath + extension;
+        if (fileExists(path.resolve(absoluteEntryPointPath, filePath))) {
+          possiblePaths.push(path.join(relativeEntryPointPath, filePath));
+        }
+      }
+    }
+
+    if (possiblePaths.length > 0) {
+      message +=
+        `\nDid you mean to set the main field to${
+          possiblePaths.length > 1 ? " one of" : ""
+        }:\n` +
+        "```\n" +
+        possiblePaths.map((filePath) => `main = "./${filePath}"\n`).join("") +
+        "```";
+    }
+  }
+  return message;
+}

package/src/generate-auth-url.ts

@@ -0,0 +1,33 @@
+interface GenerateAuthUrlProps {
+  authUrl: string;
+  clientId: string;
+  callbackUrl: string;
+  scopes: string[];
+  stateQueryParam: string;
+  codeChallenge: string;
+}
+
+/**
+ * generateAuthUrl was extracted from getAuthURL in user.tsx
+ * to make it possible to mock the generated URL
+ */
+export const generateAuthUrl = ({
+  authUrl,
+  clientId,
+  callbackUrl,
+  scopes,
+  stateQueryParam,
+  codeChallenge,
+}: GenerateAuthUrlProps) => {
+  return (
+    authUrl +
+    `?response_type=code&` +
+    `client_id=${encodeURIComponent(clientId)}&` +
+    `redirect_uri=${encodeURIComponent(callbackUrl)}&` +
+    // we add offline_access manually for every request
+    `scope=${encodeURIComponent([...scopes, "offline_access"].join(" "))}&` +
+    `state=${stateQueryParam}&` +
+    `code_challenge=${encodeURIComponent(codeChallenge)}&` +
+    `code_challenge_method=S256`
+  );
+};

package/src/generate-random-state.ts

@@ -0,0 +1,16 @@
+import { webcrypto as crypto } from "node:crypto";
+import { PKCE_CHARSET } from "./user";
+
+/**
+ * Generates random state to be passed for anti-csrf.
+ * extracted from  user.tsx to make it possible to
+ * mock the generated URL
+ */
+export function generateRandomState(lengthOfState: number): string {
+  const output = new Uint32Array(lengthOfState);
+  // @ts-expect-error crypto's types aren't there yet
+  crypto.getRandomValues(output);
+  return Array.from(output)
+    .map((num: number) => PKCE_CHARSET[num % PKCE_CHARSET.length])
+    .join("");
+}

package/src/git-client.ts

@@ -0,0 +1,42 @@
+import { execa } from "execa";
+import { findUp } from "find-up";
+
+/**
+ * Check whether the given current working directory is within a git repository
+ * by looking for a `.git` directory in this or an ancestor directory.
+ */
+export async function isInsideGitRepo(cwd: string) {
+  const res = await findUp(".git", { cwd, type: "directory" });
+  return res !== undefined;
+}
+
+/**
+ * Check whether git is installed by trying to run it.
+ */
+export async function isGitInstalled() {
+  try {
+    return (await execa("git", ["--version"])).exitCode === 0;
+  } catch (err) {
+    return false;
+  }
+}
+
+/**
+ * Initialize a new Worker project with a git repository.
+ *
+ * We want the branch to be called `main` but earlier versions of git do not support `--initial-branch`.
+ * If that is the case then we just fallback to the default initial branch name.
+ */
+export async function initializeGit(cwd: string) {
+  try {
+    // Try to create the repository with the HEAD branch of `main`.
+    await execa("git", ["init", "--initial-branch", "main"], {
+      cwd,
+    });
+  } catch {
+    // Unable to create the repo with a HEAD branch name, so just fall back to the default.
+    await execa("git", ["init"], {
+      cwd,
+    });
+  }
+}