wrangler 0.0.21 → 0.0.24

package/src/sites.tsx

@@ -4,13 +4,13 @@ import ignore from "ignore";
 import xxhash from "xxhash-wasm";
 import {
   createNamespace,
-  getKeyValue,
   listNamespaceKeys,
   listNamespaces,
   putBulkKeyValue,
+  deleteBulkKeyValue,
 } from "./kv";
 import type { Config } from "./config";
-import type { KeyValue, NamespaceKeyInfo } from "./kv";
+import type { KeyValue } from "./kv";
 import type { XXHashAPI } from "xxhash-wasm";
 
 /** Paths to always ignore. */
@@ -18,7 +18,6 @@ const ALWAYS_IGNORE = new Set(["node_modules"]);
 const HIDDEN_FILES_TO_INCLUDE = new Set([
   ".well-known", // See https://datatracker.ietf.org/doc/html/rfc8615
 ]);
-const FIVE_MINUTES = 60 * 5; // expressed in seconds, since that's what the api expects
 
 async function* getFilesInFolder(dirPath: string): AsyncIterable<string> {
   const files = await readdir(dirPath, { withFileTypes: true });
@@ -125,10 +124,7 @@ export async function syncAssets(
 
   // let's get all the keys in this namespace
   const result = await listNamespaceKeys(accountId, namespace);
-  const keyMap = result.reduce<Record<string, NamespaceKeyInfo>>(
-    (km, key) => Object.assign(km, { [key.name]: key }),
-    {}
-  );
+  const keys = new Set(result.map((x) => x.name));
 
   const manifest: Record<string, string> = {};
   const toUpload: KeyValue[] = [];
@@ -137,23 +133,28 @@ export async function syncAssets(
   const exclude = createPatternMatcher(siteAssets.excludePatterns, true);
   const hasher = await xxhash();
 
-  for await (const file of getFilesInFolder(siteAssets.baseDirectory)) {
-    if (!include(file)) {
+  const assetDirectory = path.join(
+    siteAssets.baseDirectory,
+    siteAssets.assetDirectory
+  );
+  for await (const absAssetFile of getFilesInFolder(assetDirectory)) {
+    const assetFile = path.relative(siteAssets.baseDirectory, absAssetFile);
+    if (!include(assetFile)) {
       continue;
     }
-    if (exclude(file)) {
+    if (exclude(assetFile)) {
       continue;
     }
 
-    await validateAssetSize(file);
-    console.log(`reading ${file}...`);
-    const content = await readFile(file, "base64");
+    await validateAssetSize(absAssetFile, assetFile);
+    console.log(`reading ${assetFile}...`);
+    const content = await readFile(absAssetFile, "base64");
 
-    const assetKey = hashAsset(hasher, file, content);
+    const assetKey = hashAsset(hasher, assetFile, content);
     validateAssetKey(assetKey);
 
     // now put each of the files into kv
-    if (!(assetKey in keyMap) || keyMap[assetKey].expiration) {
+    if (!keys.has(assetKey)) {
       console.log(`uploading as ${assetKey}...`);
       toUpload.push({
         key: assetKey,
@@ -163,43 +164,26 @@ export async function syncAssets(
     } else {
       console.log(`skipping - already uploaded`);
     }
-    // remove the key from the set so we know we've seen it
-    delete keyMap[assetKey];
-    manifest[path.relative(siteAssets.baseDirectory, file)] = assetKey;
-  }
 
-  // `keyMap` now contains the assets that we need to expire
+    // remove the key from the set so we know what we've already uploaded
+    keys.delete(assetKey);
+    manifest[path.relative(siteAssets.assetDirectory, absAssetFile)] = assetKey;
+  }
 
-  let toExpire: KeyValue[] = [];
-  for (const asset of Object.values(keyMap)) {
-    if (!asset.expiration) {
-      console.log(`expiring unused ${asset.name}...`);
-      toExpire.push({
-        key: asset.name,
-        value: "", // we'll fill all the values in one go
-        // we use expiration_ttl, since we can't trust the time
-        // that a deploy source might provide (eg - https://github.com/cloudflare/wrangler/issues/2224)
-        expiration_ttl: FIVE_MINUTES,
-        base64: true,
-      });
-    }
+  // keys now contains all the files we're deleting
+  for (const key of keys) {
+    console.log(`deleting ${key} from the asset store...`);
   }
 
-  // TODO: batch these in groups if it causes problems
-  toExpire = await Promise.all(
-    toExpire.map(async (asset) => ({
-      ...asset,
-      // it would be great if we didn't have to do this fetch at all
-      value: await getKeyValue(accountId, namespace, asset.key),
-    }))
-  );
+  await Promise.all([
+    // upload all the new assets
+    putBulkKeyValue(accountId, namespace, toUpload, () => {}),
+    // delete all the unused assets
+    deleteBulkKeyValue(accountId, namespace, Array.from(keys), () => {}),
+  ]);
+
+  console.log("↗️  Done syncing assets");
 
-  await putBulkKeyValue(
-    accountId,
-    namespace,
-    toUpload.concat(toExpire),
-    () => {}
-  );
   return { manifest, namespace };
 }
 
@@ -215,11 +199,14 @@ function createPatternMatcher(
   }
 }
 
-async function validateAssetSize(filePath: string) {
-  const { size } = await stat(filePath);
+async function validateAssetSize(
+  absFilePath: string,
+  relativeFilePath: string
+) {
+  const { size } = await stat(absFilePath);
   if (size > 25 * 1024 * 1024) {
     throw new Error(
-      `File ${filePath} is too big, it should be under 25 MiB. See https://developers.cloudflare.com/workers/platform/limits#kv-limits`
+      `File ${relativeFilePath} is too big, it should be under 25 MiB. See https://developers.cloudflare.com/workers/platform/limits#kv-limits`
     );
   }
 }
@@ -245,8 +232,23 @@ function urlSafe(filePath: string): string {
  * Information about the assets that should be uploaded
  */
 export interface AssetPaths {
+  /**
+   * Absolute path to the root of the project.
+   *
+   * This is the directory containing wrangler.toml or cwd if no config.
+   */
   baseDirectory: string;
+  /**
+   * The path to the assets directory, relative to the `baseDirectory`.
+   */
+  assetDirectory: string;
+  /**
+   * An array of patterns that match files that should be uploaded.
+   */
   includePatterns: string[];
+  /**
+   * An array of patterns that match files that should not be uploaded.
+   */
   excludePatterns: string[];
 }
 
@@ -259,13 +261,18 @@ export interface AssetPaths {
  */
 export function getAssetPaths(
   config: Config,
-  baseDirectory = config.site?.bucket,
+  assetDirectory = config.site?.bucket,
   includePatterns = config.site?.include ?? [],
   excludePatterns = config.site?.exclude ?? []
 ): undefined | AssetPaths {
-  return baseDirectory
+  const baseDirectory = path.resolve(
+    path.dirname(config.configPath ?? "wrangler.toml")
+  );
+
+  return assetDirectory
     ? {
         baseDirectory,
+        assetDirectory,
         includePatterns,
         excludePatterns,
       }

package/src/tail/printing.ts

@@ -24,13 +24,13 @@ export function prettyPrintLogs(data: WebSocket.RawData): void {
 
   if (eventMessage.logs.length > 0) {
     eventMessage.logs.forEach(({ level, message }) => {
-      console.log(`  (${level}) ${message}`);
+      console.log(`  (${level})`, message);
     });
   }
 
   if (eventMessage.exceptions.length > 0) {
     eventMessage.exceptions.forEach(({ name, message }) => {
-      console.error(`  ${name}: ${message}`);
+      console.error(`  ${name}:`, message);
     });
   }
 }

package/src/user.tsx

@@ -610,8 +610,8 @@ export async function getAuthURL(scopes = ScopeKeys): Promise<string> {
     `?response_type=code&` +
     `client_id=${encodeURIComponent(CLIENT_ID)}&` +
     `redirect_uri=${encodeURIComponent(CALLBACK_URL)}&` +
-    // @ts-expect-error we add offline_access manually
-    `scope=${encodeURIComponent(scopes.concat("offline_access").join(" "))}&` +
+    // we add offline_access manually for every request
+    `scope=${encodeURIComponent([...scopes, "offline_access"].join(" "))}&` +
     `state=${stateQueryParam}&` +
     `code_challenge=${encodeURIComponent(codeChallenge)}&` +
     `code_challenge_method=S256`
@@ -864,7 +864,16 @@ export async function loginOrRefreshIfRequired(
     // If we are not interactive, we cannot ask the user to login
     return isInteractive && (await login());
   } else if (isAccessTokenExpired()) {
-    return await refreshToken();
+    // We're logged in, but the refresh token seems to have expired,
+    // so let's try to refresh it
+    const didRefresh = await refreshToken();
+    if (didRefresh) {
+      // The token was refreshed, so we're done here
+      return true;
+    } else {
+      // If the refresh token isn't valid, then we ask the user to login again
+      return isInteractive && (await login());
+    }
   } else {
     return true;
   }