wrangler 0.0.0-e14e589 → 0.0.0-e2a26a0

package/src/publish.ts

@@ -1,27 +1,36 @@
-import type { CfWorkerInit } from "./api/worker";
-import { toFormData } from "./api/form_data";
-import esbuild from "esbuild";
-import tmp from "tmp-promise";
-import type { Config } from "./config";
-import path from "path";
-import { readFile } from "fs/promises";
-import cfetch from "./cfetch";
 import assert from "node:assert";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { URLSearchParams } from "node:url";
+import * as esbuild from "esbuild";
+import { execaCommand } from "execa";
+import tmp from "tmp-promise";
+import { toFormData } from "./api/form_data";
+import { fetchResult } from "./cfetch";
+import makeModuleCollector from "./module-collection";
 import { syncAssets } from "./sites";
+import type { CfWorkerInit } from "./api/worker";
+import type { Config } from "./config";
+import type { AssetPaths } from "./sites";
+import type { Metafile } from "esbuild";
 
-type CfScriptFormat = void | "modules" | "service-worker";
+type CfScriptFormat = undefined | "modules" | "service-worker";
 
 type Props = {
   config: Config;
-  format?: CfScriptFormat;
-  script?: string;
-  name?: string;
-  env?: string;
-  public?: string;
-  site?: string;
-  triggers?: (string | number)[];
-  routes?: (string | number)[];
-  legacyEnv?: boolean;
+  format: CfScriptFormat | undefined;
+  script: string | undefined;
+  name: string | undefined;
+  env: string | undefined;
+  compatibilityDate: string | undefined;
+  compatibilityFlags: string[] | undefined;
+  assetPaths: AssetPaths | undefined;
+  triggers: (string | number)[] | undefined;
+  routes: (string | number)[] | undefined;
+  legacyEnv: boolean | undefined;
+  jsxFactory: undefined | string;
+  jsxFragment: undefined | string;
+  experimentalPublic: boolean;
 };
 
 function sleep(ms: number) {
@@ -29,10 +38,10 @@ function sleep(ms: number) {
 }
 
 export default async function publish(props: Props): Promise<void> {
-  if (props.public && props.format === "service-worker") {
+  if (props.experimentalPublic && props.format === "service-worker") {
     // TODO: check config too
     throw new Error(
-      "You cannot use the service worker format with a public directory."
+      "You cannot publish in the service worker format with a public directory."
     );
   }
   // TODO: warn if git/hg has uncommitted changes
@@ -44,65 +53,133 @@ export default async function publish(props: Props): Promise<void> {
     __path__,
   } = config;
 
+  const envRootObj =
+    props.env && config.env ? config.env[props.env] || {} : config;
+
+  assert(
+    envRootObj.compatibility_date || props.compatibilityDate,
+    "A compatibility_date is required when publishing. Add one to your wrangler.toml file, or pass it in your terminal as --compatibility_date. See https://developers.cloudflare.com/workers/platform/compatibility-dates for more information."
+  );
+
+  if (accountId === undefined) {
+    throw new Error("No account_id provided.");
+  }
+
   const triggers = props.triggers || config.triggers?.crons;
   const routes = props.routes || config.routes;
 
+  const jsxFactory = props.jsxFactory || config.jsx_factory;
+  const jsxFragment = props.jsxFragment || config.jsx_fragment;
+
   assert(config.account_id, "missing account id");
 
+  let scriptName = props.name || config.name;
+  assert(
+    scriptName,
+    'You need to provide a name when publishing a worker. Either pass it as a cli arg with `--name <name>` or in your config file as `name = "<name>"`'
+  );
+
+  if (config.site?.["entry-point"]) {
+    console.warn(
+      "Deprecation notice: The `site.entry-point` config field is no longer used.\n" +
+        "The entry-point should be specified via the command line (e.g. `wrangler publish path/to/script`) or the `build.upload.main` config field.\n" +
+        "Please remove the `site.entry-point` field from the `wrangler.toml` file."
+    );
+  }
+
+  assert(
+    !config.site || config.site.bucket,
+    "A [site] definition requires a `bucket` field with a path to the site's public directory."
+  );
+
   let file: string;
   if (props.script) {
-    file = props.script;
-    assert(props.name, "name is required when using script");
+    // If the script name comes from the command line it is relative to the current working directory.
+    file = path.resolve(props.script);
   } else {
-    assert(build?.upload?.main, "missing main file");
-    assert(config.name, "missing name");
-    file = path.join(path.dirname(__path__), build.upload.main);
+    // If the script name comes from the config, then it is relative to the wrangler.toml file.
+    if (build?.upload?.main === undefined) {
+      throw new Error(
+        "Missing entry-point: The entry-point should be specified via the command line (e.g. `wrangler publish path/to/script`) or the `build.upload.main` config field."
+      );
+    }
+    file = path.resolve(path.dirname(__path__), build.upload.main);
   }
 
-  let scriptName = props.script ? props.name : config.name;
   if (props.legacyEnv) {
     scriptName += props.env ? `-${props.env}` : "";
   }
   const envName = props.env ?? "production";
 
   const destination = await tmp.dir({ unsafeCleanup: true });
+  if (props.config.build?.command) {
+    // TODO: add a deprecation message here?
+    console.log("running:", props.config.build.command);
+    await execaCommand(props.config.build.command, {
+      shell: true,
+      stdout: "inherit",
+      stderr: "inherit",
+      ...(props.config.build?.cwd && { cwd: props.config.build.cwd }),
+    });
+  }
 
+  const moduleCollector = makeModuleCollector();
   const result = await esbuild.build({
-    ...(props.public
+    ...(props.experimentalPublic
       ? {
           stdin: {
             contents: (
               await readFile(
-                path.join(__dirname, "../static-asset-facade.js"),
+                path.join(__dirname, "../templates/static-asset-facade.js"),
                 "utf8"
               )
-            ).replace("__ENTRY_POINT__", path.join(process.cwd(), file)),
+            ).replace("__ENTRY_POINT__", file),
             sourcefile: "static-asset-facade.js",
             resolveDir: path.dirname(file),
           },
+          nodePaths: [path.join(__dirname, "../vendor")],
         }
       : { entryPoints: [file] }),
     bundle: true,
-    nodePaths: props.public ? [path.join(__dirname, "../vendor")] : undefined,
     outdir: destination.path,
     external: ["__STATIC_CONTENT_MANIFEST"],
     format: "esm",
     sourcemap: true,
     metafile: true,
+    conditions: ["worker", "browser"],
+    loader: {
+      ".js": "jsx",
+      ".html": "text",
+      ".pem": "text",
+      ".txt": "text",
+    },
+    plugins: [moduleCollector.plugin],
+    ...(jsxFactory && { jsxFactory }),
+    ...(jsxFragment && { jsxFragment }),
   });
 
-  const chunks = Object.entries(result.metafile.outputs).find(
-    ([_path, { entryPoint }]) =>
-      entryPoint ===
-      (props.public
-        ? path.join(path.dirname(file), "static-asset-facade.js")
-        : file)
+  // result.metafile is defined because of the `metafile: true` option above.
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  const metafile = result.metafile!;
+  const entryPoints = Object.entries(metafile.outputs).filter(
+    ([_path, output]) => output.entryPoint !== undefined
   );
-
+  assert(
+    entryPoints.length > 0,
+    `Cannot find entry-point "${file}" in generated bundle.` +
+      listEntryPoints(entryPoints)
+  );
+  assert(
+    entryPoints.length < 2,
+    "More than one entry-point found for generated bundle." +
+      listEntryPoints(entryPoints)
+  );
+  const entryPointExports = entryPoints[0][1].exports;
+  const resolvedEntryPointPath = entryPoints[0][0];
   const { format } = props;
   const bundle = {
-    type: chunks[1].exports.length > 0 ? "esm" : "commonjs",
-    exports: chunks[1].exports,
+    type: entryPointExports.length > 0 ? "esm" : "commonjs",
+    exports: entryPointExports,
   };
 
   // TODO: instead of bundling the facade with the worker, we should just bundle the worker and expose it as a module.
@@ -119,54 +196,101 @@ export default async function publish(props: Props): Promise<void> {
     return;
   }
 
-  const content = await readFile(chunks[0], { encoding: "utf-8" });
-  destination.cleanup();
-  const assets =
-    props.public || props.site || props.config.site?.bucket // TODO: allow both
-      ? await syncAssets(
-          accountId,
-          scriptName,
-          props.public || props.site || props.config.site?.bucket,
-          false
-        )
-      : { manifest: undefined, namespace: undefined };
+  let content = await readFile(resolvedEntryPointPath, { encoding: "utf-8" });
+  await destination.cleanup();
+
+  // if config.migrations
+  // get current migration tag
+  let migrations;
+  if (config.migrations !== undefined) {
+    const scripts = await fetchResult<{ id: string; migration_tag: string }[]>(
+      `/accounts/${accountId}/workers/scripts`
+    );
+    const script = scripts.find(({ id }) => id === scriptName);
+    if (script?.migration_tag) {
+      // was already published once
+      const foundIndex = config.migrations.findIndex(
+        (migration) => migration.tag === script.migration_tag
+      );
+      if (foundIndex === -1) {
+        console.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 {
+        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 {
+      migrations = {
+        new_tag: config.migrations[config.migrations.length - 1].tag,
+        steps: config.migrations.map(({ tag: _tag, ...rest }) => rest),
+      };
+    }
+  }
+
+  const assets = await syncAssets(
+    accountId,
+    scriptName,
+    props.assetPaths,
+    false,
+    props.env
+  );
 
-  const envRootObj = props.env ? config[`env.${props.env}`] : config;
+  const bindings: CfWorkerInit["bindings"] = {
+    kv_namespaces: (envRootObj.kv_namespaces || []).concat(
+      assets.namespace
+        ? { binding: "__STATIC_CONTENT", id: assets.namespace }
+        : []
+    ),
+    vars: envRootObj.vars,
+    durable_objects: envRootObj.durable_objects,
+    services: envRootObj.experimental_services,
+  };
+
+  const workerType = bundle.type === "esm" ? "esm" : "commonjs";
+  if (workerType !== "esm" && assets.manifest) {
+    content = `const __STATIC_CONTENT_MANIFEST = ${JSON.stringify(
+      assets.manifest
+    )};\n${content}`;
+  }
 
   const worker: CfWorkerInit = {
+    name: scriptName,
     main: {
-      name: scriptName,
+      name: path.basename(resolvedEntryPointPath),
       content: content,
-      type:
-        (bundle.type === "esm" ? "modules" : "service-worker") === "modules"
-          ? "esm"
-          : "commonjs",
-    },
-    variables: {
-      ...(envRootObj?.vars || {}),
-      ...(envRootObj?.kv_namespaces || []).reduce(
-        (obj, { binding, preview_id, id }) => {
-          return { ...obj, [binding]: { namespaceId: id } };
-        },
-        {}
-      ),
-      ...(assets.namespace
-        ? { __STATIC_CONTENT: { namespaceId: assets.namespace } }
-        : {}),
+      type: workerType,
     },
-    modules: assets.manifest
-      ? [].concat({
-          name: "__STATIC_CONTENT_MANIFEST",
-          content: JSON.stringify(assets.manifest),
-          type: "text",
-        })
-      : [],
+    bindings,
+    ...(migrations && { migrations }),
+    modules: moduleCollector.modules.concat(
+      assets.manifest && workerType === "esm"
+        ? {
+            name: "__STATIC_CONTENT_MANIFEST",
+            content: JSON.stringify(assets.manifest),
+            type: "text",
+          }
+        : []
+    ),
+    compatibility_date: config.compatibility_date,
+    compatibility_flags: config.compatibility_flags,
+    usage_model: config.usage_model,
   };
 
   const start = Date.now();
-  const formatTime = (duration) => {
+  function formatTime(duration: number) {
     return `(${(duration / 1000).toFixed(2)} sec)`;
-  };
+  }
 
   const notProd = !props.legacyEnv && props.env;
   const workerName = notProd ? `${scriptName} (${envName})` : scriptName;
@@ -174,14 +298,14 @@ export default async function publish(props: Props): Promise<void> {
     ? `/accounts/${accountId}/workers/services/${scriptName}/environments/${envName}`
     : `/accounts/${accountId}/workers/scripts/${scriptName}`;
 
-  // Upload the script so it has time to propogate.
-  const { available_on_subdomain } = await cfetch(
-    `${workerUrl}?available_on_subdomain=true`,
+  // Upload the script so it has time to propagate.
+  const { available_on_subdomain } = await fetchResult(
+    workerUrl,
     {
       method: "PUT",
-      // @ts-expect-error: TODO: fix this type error!
       body: toFormData(worker),
-    }
+    },
+    new URLSearchParams({ available_on_subdomains: "true" })
   );
 
   const uploadMs = Date.now() - start;
@@ -189,7 +313,7 @@ export default async function publish(props: Props): Promise<void> {
   const deployments: Promise<string[]>[] = [];
 
   const userSubdomain = (
-    await cfetch<{ subdomain: string }>(
+    await fetchResult<{ subdomain: string }>(
       `/accounts/${accountId}/workers/subdomain`
     )
   ).subdomain;
@@ -203,7 +327,7 @@ export default async function publish(props: Props): Promise<void> {
   // TODO: Make this configurable.
   if (!available_on_subdomain) {
     deployments.push(
-      cfetch(`${workerUrl}/subdomain`, {
+      fetchResult(`${workerUrl}/subdomain`, {
         method: "POST",
         body: JSON.stringify({ enabled: true }),
         headers: {
@@ -215,8 +339,8 @@ export default async function publish(props: Props): Promise<void> {
         // This is to prevent an issue where a negative cache-hit
         // causes the subdomain to be unavailable for 30 seconds.
         // This is a temporary measure until we fix this on the edge.
-        .then((url) => {
-          sleep(3000);
+        .then(async (url) => {
+          await sleep(3000);
           return url;
         })
     );
@@ -227,7 +351,7 @@ export default async function publish(props: Props): Promise<void> {
   // Update routing table for the script.
   if (routes && routes.length) {
     deployments.push(
-      cfetch(`${workerUrl}/routes`, {
+      fetchResult(`${workerUrl}/routes`, {
         // TODO: PATCH will not delete previous routes on this script,
         // whereas PUT will. We need to decide on the default behaviour
         // and how to configure it.
@@ -252,7 +376,7 @@ export default async function publish(props: Props): Promise<void> {
   // TODO: rename this to `schedules`?
   if (triggers && triggers.length) {
     deployments.push(
-      cfetch(`${workerUrl}/schedules`, {
+      fetchResult(`${workerUrl}/schedules`, {
         // TODO: Unlike routes, this endpoint does not support PATCH.
         // So technically, this will override any previous schedules.
         // We should change the endpoint to support PATCH.
@@ -276,3 +400,11 @@ export default async function publish(props: Props): Promise<void> {
     console.log(" ", target);
   }
 }
+
+function listEntryPoints(
+  outputs: [string, ValueOf<Metafile["outputs"]>][]
+): string {
+  return outputs.map(([_input, output]) => output.entryPoint).join("\n");
+}
+
+type ValueOf<T> = T[keyof T];