wrangler 0.0.0-e14e589 → 0.0.0-e2a26a0

package/src/kv.tsx

@@ -1,6 +1,6 @@
+import { URLSearchParams } from "node:url";
+import { fetchListResult, fetchResult, fetchKVGetValue } from "./cfetch";
 import type { Config } from "./config";
-import cfetch from "./cfetch";
-import qs from "node:querystring";
 
 type KvArgs = {
   binding?: string;
@@ -10,38 +10,84 @@ type KvArgs = {
   config?: Config;
 };
 
-export async function listNamespaces(accountId: string) {
-  let page = 1,
-    done = false,
-    results = [];
-  while (!(done || results.length % 100 !== 0)) {
-    const json = await cfetch<
-      { id: string; title: string; supports_url_encoding: boolean }[]
-    >(
-      `/accounts/${accountId}/storage/kv/namespaces?per_page=100&order=title&direction=asc&page=${page}`
+/**
+ * Create a new namespace under the given `accountId` with the given `title`.
+ *
+ * @returns the generated id of the created namespace.
+ */
+export async function createNamespace(
+  accountId: string,
+  title: string
+): Promise<string> {
+  const response = await fetchResult<{ id: string }>(
+    `/accounts/${accountId}/storage/kv/namespaces`,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        title,
+      }),
+    }
+  );
+
+  return response.id;
+}
+
+/**
+ * The information about a namespace that is returned from `listNamespaces()`.
+ */
+export interface KVNamespaceInfo {
+  id: string;
+  title: string;
+  supports_url_encoding?: boolean;
+}
+
+/**
+ * Fetch a list of all the namespaces under the given `accountId`.
+ */
+export async function listNamespaces(
+  accountId: string
+): Promise<KVNamespaceInfo[]> {
+  const pageSize = 100;
+  let page = 1;
+  const results: KVNamespaceInfo[] = [];
+  while (results.length % pageSize === 0) {
+    const json = await fetchResult<KVNamespaceInfo[]>(
+      `/accounts/${accountId}/storage/kv/namespaces`,
+      {},
+      new URLSearchParams({
+        per_page: pageSize.toString(),
+        order: "title",
+        direction: "asc",
+        page: page.toString(),
+      })
     );
     page++;
-    results = [...results, ...json];
-    if (json.length === 0) {
-      done = true;
+    results.push(...json);
+    if (json.length < pageSize) {
+      break;
     }
   }
   return results;
 }
 
+export interface NamespaceKeyInfo {
+  name: string;
+  expiration?: number;
+  metadata?: { [key: string]: unknown };
+}
+
 export async function listNamespaceKeys(
   accountId: string,
   namespaceId: string,
-  prefix?: string,
-  limit?: number
+  prefix = ""
 ) {
-  // TODO: this doesn't appear to do pagination
-  return await cfetch<
-    { name: string; expiration: number; metadata: { [key: string]: unknown } }[]
-  >(
-    `/accounts/${accountId}/storage/kv/namespaces/${namespaceId}/keys?${qs.stringify(
-      { prefix, limit }
-    )}`
+  return await fetchListResult<NamespaceKeyInfo>(
+    `/accounts/${accountId}/storage/kv/namespaces/${namespaceId}/keys`,
+    {},
+    new URLSearchParams({ prefix })
   );
 }
 
@@ -52,25 +98,37 @@ export async function putKeyValue(
   value: string,
   args?: { expiration?: number; expiration_ttl?: number }
 ) {
-  return await cfetch(
-    `/accounts/${accountId}/storage/kv/namespaces/${namespaceId}/values/${key}?${
-      args
-        ? qs.stringify({
-            expiration: args.expiration,
-            expiration_ttl: args.expiration_ttl,
-          })
-        : ""
-    }`,
-    { method: "PUT", body: value }
+  let searchParams: URLSearchParams | undefined;
+  if (args) {
+    searchParams = new URLSearchParams();
+    if (args.expiration) {
+      searchParams.set("expiration", `${args.expiration}`);
+    }
+    if (args.expiration_ttl) {
+      searchParams.set("expiration_ttl", `${args.expiration_ttl}`);
+    }
+  }
+  return await fetchResult(
+    `/accounts/${accountId}/storage/kv/namespaces/${namespaceId}/values/${key}`,
+    { method: "PUT", body: value },
+    searchParams
   );
 }
 
+export async function getKeyValue(
+  accountId: string,
+  namespaceId: string,
+  key: string
+): Promise<string> {
+  return await fetchKVGetValue(accountId, namespaceId, key);
+}
+
 export async function putBulkKeyValue(
   accountId: string,
   namespaceId: string,
   keyvalueStr: string
 ) {
-  return await cfetch(
+  return await fetchResult(
     `/accounts/${accountId}/storage/kv/namespaces/${namespaceId}/bulk`,
     {
       method: "PUT",
@@ -85,7 +143,7 @@ export async function deleteBulkKeyValue(
   namespaceId: string,
   keyStr: string
 ) {
-  return await cfetch(
+  return await fetchResult(
     `/accounts/${accountId}/storage/kv/namespaces/${namespaceId}/bulk`,
     {
       method: "DELETE",
@@ -118,7 +176,7 @@ export function getNamespaceId({
   if (!config) {
     throw new Error(
       "Failed to find a config file.\n" +
-        "Either use --namespace to upload directly or create a configuration file with a binding."
+        "Either use --namespace-id to upload directly or create a configuration file with a binding."
     );
   }
 
@@ -130,7 +188,7 @@ export function getNamespaceId({
       );
     }
 
-    // TODO: either a bespoke arg type for this function to avoid undefineds or a EnvOrConfig type
+    // TODO: either a bespoke arg type for this function to avoid `undefined`s or an `EnvOrConfig` type
     return getNamespaceId({
       binding,
       "namespace-id": namespaceId,
@@ -149,25 +207,27 @@ export function getNamespaceId({
   // there's no KV namespaces
   if (!config.kv_namespaces || config.kv_namespaces.length === 0) {
     throw new Error(
-      "No KV Namespace to upload to! Either use --namespace to upload directly or add a KV namespace to your wrangler config file."
+      "No KV Namespaces configured! Either use --namespace-id to upload directly or add a KV namespace to your wrangler config file."
     );
   }
 
-  const namespace = config.kv_namespaces.find(
-    (namespace) => namespace.binding === binding
-  );
+  const namespace = config.kv_namespaces.find((ns) => ns.binding === binding);
 
   // we couldn't find a namespace with that binding
   if (!namespace) {
-    throw new Error(`No KV Namespaces found with binding ${binding}!`);
+    throw new Error(
+      `A namespace with binding name "${binding}" was not found in the configured "kv_namespaces".`
+    );
   }
 
   // end pre-flight checks
 
-  // we're in preview mode, `--preview true` or `--preivew` was passed
+  // we're in preview mode, `--preview true` or `--preview` was passed
   if (preview && namespace.preview_id) {
     namespaceId = namespace.preview_id;
-  } else {
+    // We don't want to execute code below if preview is set to true, so we just return. Otherwise we will get errors!
+    return namespaceId;
+  } else if (preview) {
     throw new Error(
       `No preview ID found for ${binding}. Add one to your wrangler config file to use a separate namespace for previewing your worker.`
     );
@@ -180,7 +240,9 @@ export function getNamespaceId({
   // --preview false was passed
   if (previewIsDefined && namespace.id) {
     namespaceId = namespace.id;
-  } else {
+    // We don't want to execute code below if preview is set to true, so we just return. Otherwise we can get error!
+    return namespaceId;
+  } else if (previewIsDefined) {
     throw new Error(
       `No namespace ID found for ${binding}. Add one to your wrangler config file to use a separate namespace for previewing your worker.`
     );
@@ -209,3 +271,14 @@ export function getNamespaceId({
 
   return namespaceId;
 }
+
+/**
+ * KV namespace binding names must be valid JS identifiers.
+ */
+export function isValidNamespaceBinding(
+  binding: string | undefined
+): binding is string {
+  return (
+    typeof binding === "string" && /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(binding)
+  );
+}

package/src/module-collection.ts

@@ -0,0 +1,63 @@
+import crypto from "node:crypto";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import type { CfModule } from "./api/worker";
+import type esbuild from "esbuild";
+
+// This is a combination of an esbuild plugin and a mutable array
+// that we use to collect module references from source code.
+// There will be modules that _shouldn't_ be inlined directly into
+// the bundle. (eg. wasm modules, some text files, etc). We can include
+// those files as modules in the multi part forker form upload. This
+// plugin+array is used to collect references to these modules, reference
+// them correctly in the bundle, and add them to the form upload.
+
+export default function makeModuleCollector(): {
+  modules: CfModule[];
+  plugin: esbuild.Plugin;
+} {
+  const modules: CfModule[] = [];
+  return {
+    modules,
+    plugin: {
+      name: "wrangler-module-collector",
+      setup(build) {
+        build.onStart(() => {
+          // reset the moduels collection
+          modules.splice(0);
+        });
+
+        build.onResolve(
+          // filter on "known" file types,
+          // we can expand this list later
+          { filter: /.*\.(wasm)$/ },
+          async (args: esbuild.OnResolveArgs) => {
+            // take the file and massage it to a
+            // transportable/manageable format
+            const filePath = path.join(args.resolveDir, args.path);
+            const fileContent = await readFile(filePath);
+            const fileHash = crypto
+              .createHash("sha1")
+              .update(fileContent)
+              .digest("hex");
+            const fileName = `${fileHash}-${path.basename(args.path)}`;
+
+            // add the module to the array
+            modules.push({
+              name: fileName,
+              content: fileContent,
+              type: "compiled-wasm",
+            });
+
+            return {
+              path: fileName, // change the reference to the changed module
+              external: true, // mark it as external in the bundle
+              namespace: "wrangler-module-collector-ns", // just a tag, this isn't strictly necessary
+              watchFiles: [filePath], // we also add the file to esbuild's watch list
+            };
+          }
+        );
+      },
+    },
+  };
+}

package/src/package-manager.ts

@@ -0,0 +1,120 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { execa, execaCommandSync } from "execa";
+
+export interface PackageManager {
+  addDevDeps(...packages: string[]): Promise<void>;
+  install(): Promise<void>;
+}
+
+export async function getPackageManager(root: string): Promise<PackageManager> {
+  const [hasYarn, hasNpm] = await Promise.all([supportsYarn(), supportsNpm()]);
+  const hasYarnLock = existsSync(join(root, "yarn.lock"));
+  const hasNpmLock = existsSync(join(root, "package-lock.json"));
+
+  if (hasNpmLock) {
+    if (hasNpm) {
+      console.log(
+        "Using npm as package manager, as there is already a package-lock.json file."
+      );
+      return NpmPackageManager;
+    } else if (hasYarn) {
+      console.log("Using yarn as package manager.");
+      console.warn(
+        "There is already a package-lock.json file but could not find npm on the PATH."
+      );
+      return YarnPackageManager;
+    }
+  } else if (hasYarnLock) {
+    if (hasYarn) {
+      console.log(
+        "Using yarn as package manager, as there is already a yarn.lock file."
+      );
+      return YarnPackageManager;
+    } else if (hasNpm) {
+      console.log("Using npm as package manager.");
+      console.warn(
+        "There is already a yarn.lock file but could not find yarn on the PATH."
+      );
+      return NpmPackageManager;
+    }
+  }
+
+  if (hasNpm) {
+    console.log("Using npm as package manager.");
+    return NpmPackageManager;
+  } else if (hasYarn) {
+    console.log("Using yarn as package manager.");
+    return YarnPackageManager;
+  } else {
+    throw new Error(
+      "Unable to find a package manager. Supported managers are: npm and yarn."
+    );
+  }
+}
+
+/**
+ * Get the name of the given `packageManager`.
+ */
+export function getPackageManagerName(packageManager: unknown): string {
+  return packageManager === NpmPackageManager
+    ? "npm"
+    : packageManager === YarnPackageManager
+    ? "yarn"
+    : "unknown";
+}
+
+/**
+ * Manage packages using npm
+ */
+const NpmPackageManager: PackageManager = {
+  /** Add and install a new devDependency into the local package.json. */
+  async addDevDeps(...packages: string[]): Promise<void> {
+    await execa("npm", ["install", ...packages, "--save-dev"], {
+      stdio: "inherit",
+    });
+  },
+
+  /** Install all the dependencies in the local package.json. */
+  async install(): Promise<void> {
+    await execa("npm", ["install"], {
+      stdio: "inherit",
+    });
+  },
+};
+
+/**
+ * Manage packages using yarn
+ */
+const YarnPackageManager: PackageManager = {
+  /** Add and install a new devDependency into the local package.json. */
+  async addDevDeps(...packages: string[]): Promise<void> {
+    await execa("yarn", ["add", ...packages, "--dev"], {
+      stdio: "inherit",
+    });
+  },
+
+  /** Install all the dependencies in the local package.json. */
+  async install(): Promise<void> {
+    await execa("yarn", ["install"], {
+      stdio: "inherit",
+    });
+  },
+};
+
+async function supports(name: string): Promise<boolean> {
+  try {
+    execaCommandSync(`${name} --version`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function supportsYarn(): Promise<boolean> {
+  return supports("yarn");
+}
+
+function supportsNpm(): Promise<boolean> {
+  return supports("npm");
+}