wrangler 2.0.3 → 2.0.7

package/src/kv.ts

@@ -1,5 +1,6 @@
 import { URLSearchParams } from "node:url";
 import { fetchListResult, fetchResult, fetchKVGetValue } from "./cfetch";
+import { logger } from "./logger";
 import type { Config } from "./config";
 
 /** The largest number of kv items we can pass to the API in a single request. */
@@ -19,7 +20,7 @@ type KvArgs = {
  *
  * @returns the generated id of the created namespace.
  */
-export async function createNamespace(
+export async function createKVNamespace(
   accountId: string,
   title: string
 ): Promise<string> {
@@ -51,7 +52,7 @@ export interface KVNamespaceInfo {
 /**
  * Fetch a list of all the namespaces under the given `accountId`.
  */
-export async function listNamespaces(
+export async function listKVNamespaces(
   accountId: string
 ): Promise<KVNamespaceInfo[]> {
   const pageSize = 100;
@@ -83,7 +84,7 @@ export interface NamespaceKeyInfo {
   metadata?: { [key: string]: unknown };
 }
 
-export async function listNamespaceKeys(
+export async function listKVNamespaceKeys(
   accountId: string,
   namespaceId: string,
   prefix = ""
@@ -95,6 +96,16 @@ export async function listNamespaceKeys(
   );
 }
 
+export async function deleteKVNamespace(
+  accountId: string,
+  namespaceId: string
+) {
+  return await fetchResult<{ id: string }>(
+    `/accounts/${accountId}/storage/kv/namespaces/${namespaceId}`,
+    { method: "DELETE" }
+  );
+}
+
 /**
  * Information about a key-value pair, including its "metadata" fields.
  */
@@ -116,12 +127,52 @@ const KeyValueKeys = new Set([
   "base64",
 ]);
 
+/**
+ * The object has the specified property.
+ */
+function hasProperty<T extends object>(
+  obj: object,
+  property: keyof T
+): obj is T {
+  return property in obj;
+}
+
+/**
+ * The object has a required property of the specified type.
+ */
+function hasTypedProperty<T extends object>(
+  obj: object,
+  property: keyof T,
+  type: string
+): obj is T {
+  return hasProperty(obj, property) && typeof obj[property] === type;
+}
+
+/**
+ * The object an optional property, of the specified type.
+ */
+function hasOptionalTypedProperty<T extends object>(
+  obj: object,
+  property: keyof T,
+  type: string
+): obj is Omit<T, typeof property> | T {
+  return !hasProperty(obj, property) || typeof obj[property] === type;
+}
+
 /**
  * Is the given object a valid `KeyValue` type?
  */
-export function isKeyValue(keyValue: object): keyValue is KeyValue {
-  const props = Object.keys(keyValue);
-  if (!props.includes("key") || !props.includes("value")) {
+export function isKVKeyValue(keyValue: unknown): keyValue is KeyValue {
+  if (
+    keyValue === null ||
+    typeof keyValue !== "object" ||
+    !hasTypedProperty(keyValue, "key", "string") ||
+    !hasTypedProperty(keyValue, "value", "string") ||
+    !hasOptionalTypedProperty(keyValue, "expiration", "number") ||
+    !hasOptionalTypedProperty(keyValue, "expiration_ttl", "number") ||
+    !hasOptionalTypedProperty(keyValue, "base64", "boolean") ||
+    !hasOptionalTypedProperty(keyValue, "metadata", "object")
+  ) {
     return false;
   }
   return true;
@@ -130,12 +181,12 @@ export function isKeyValue(keyValue: object): keyValue is KeyValue {
 /**
  * Get all the properties on the `keyValue` that are not expected.
  */
-export function unexpectedKeyValueProps(keyValue: KeyValue): string[] {
+export function unexpectedKVKeyValueProps(keyValue: KeyValue): string[] {
   const props = Object.keys(keyValue);
   return props.filter((prop) => !KeyValueKeys.has(prop));
 }
 
-export async function putKeyValue(
+export async function putKVKeyValue(
   accountId: string,
   namespaceId: string,
   keyValue: KeyValue
@@ -159,23 +210,58 @@ export async function putKeyValue(
   );
 }
 
-export async function getKeyValue(
+export async function getKVKeyValue(
   accountId: string,
   namespaceId: string,
   key: string
 ): Promise<string> {
-  return await fetchKVGetValue(accountId, namespaceId, key);
+  return await fetchKVGetValue(accountId, namespaceId, encodeURIComponent(key));
+}
+
+export async function deleteKVKeyValue(
+  accountId: string,
+  namespaceId: string,
+  key: string
+) {
+  return await fetchResult(
+    `/accounts/${accountId}/storage/kv/namespaces/${namespaceId}/values/${encodeURIComponent(
+      key
+    )}`,
+    { method: "DELETE" }
+  );
 }
 
-export async function putBulkKeyValue(
+/**
+ * Formatter for converting e.g. 5328 --> 5,328
+ */
+const formatNumber = new Intl.NumberFormat("en-US", {
+  notation: "standard",
+}).format;
+
+/**
+ * Helper function for bulk requests, logs ongoing output to console.
+ */
+function logBulkProgress(
+  operation: "put" | "delete",
+  index: number,
+  total: number
+) {
+  logger.log(
+    `${operation === "put" ? "Uploaded" : "Deleted"} ${Math.floor(
+      (100 * index) / total
+    )}% (${formatNumber(index)} out of ${formatNumber(total)})`
+  );
+}
+
+export async function putKVBulkKeyValue(
   accountId: string,
   namespaceId: string,
   keyValues: KeyValue[],
-  progressCallback: (index: number, total: number) => void
+  quiet = false
 ) {
   for (let index = 0; index < keyValues.length; index += BATCH_KEY_MAX) {
-    if (progressCallback && keyValues.length > BATCH_KEY_MAX) {
-      progressCallback(index, keyValues.length);
+    if (!quiet && keyValues.length > BATCH_KEY_MAX) {
+      logBulkProgress("put", index, keyValues.length);
     }
 
     await fetchResult(
@@ -187,20 +273,21 @@ export async function putBulkKeyValue(
       }
     );
   }
-  if (progressCallback && keyValues.length > BATCH_KEY_MAX) {
-    progressCallback(keyValues.length, keyValues.length);
+
+  if (!quiet && keyValues.length > BATCH_KEY_MAX) {
+    logBulkProgress("put", keyValues.length, keyValues.length);
   }
 }
 
-export async function deleteBulkKeyValue(
+export async function deleteKVBulkKeyValue(
   accountId: string,
   namespaceId: string,
   keys: string[],
-  progressCallback: (index: number, total: number) => void
+  quiet = false
 ) {
   for (let index = 0; index < keys.length; index += BATCH_KEY_MAX) {
-    if (progressCallback && keys.length > BATCH_KEY_MAX) {
-      progressCallback(index, keys.length);
+    if (!quiet && keys.length > BATCH_KEY_MAX) {
+      logBulkProgress("delete", index, keys.length);
     }
 
     await fetchResult(
@@ -212,12 +299,12 @@ export async function deleteBulkKeyValue(
       }
     );
   }
-  if (progressCallback && keys.length > BATCH_KEY_MAX) {
-    progressCallback(keys.length, keys.length);
+  if (!quiet && keys.length > BATCH_KEY_MAX) {
+    logBulkProgress("delete", keys.length, keys.length);
   }
 }
 
-export function getNamespaceId(
+export function getKVNamespaceId(
   { preview, binding, "namespace-id": namespaceId }: KvArgs,
   config: Config
 ): string {
@@ -312,7 +399,7 @@ export function getNamespaceId(
 /**
  * KV namespace binding names must be valid JS identifiers.
  */
-export function isValidNamespaceBinding(
+export function isValidKVNamespaceBinding(
   binding: string | undefined
 ): binding is string {
   return (

package/src/open-in-browser.ts

@@ -8,19 +8,12 @@ import { logger } from "./logger";
  * StackBlitz, remote servers), it doesn't just crash the process.
  *
  * @param url the URL to point the browser at
- * @param options open a Chromium-based browser instead of the default
  */
-export default async function openInBrowser(
-  url: string,
-  { forceChromium }: { forceChromium: boolean } = { forceChromium: false }
-): Promise<void> {
-  const options: open.Options | undefined = forceChromium
-    ? {
-        app: [{ name: open.apps.chrome }, { name: open.apps.edge }],
-      }
-    : undefined;
-  const childProcess = await open(url, options);
+export default async function openInBrowser(url: string): Promise<void> {
+  const errorMessage = `Failed to open ${url} in a browser`;
+
+  const childProcess = await open(url);
   childProcess.on("error", () => {
-    logger.warn(`Failed to open ${url} in a browser.`);
+    logger.warn(errorMessage);
   });
 }