wrangler 0.0.0-e3cab74 → 0.0.0-e3ce82b

package/src/selfsigned.d.ts

@@ -0,0 +1,29 @@
+declare module "selfsigned" {
+  import type { pki } from "node-forge";
+
+  export type Attributes = pki.CertificateField[];
+
+  export interface Options {
+    days?: number;
+    keySize?: number;
+    extensions?: unknown[];
+    algorithm?: string;
+    pkcs7?: boolean;
+    clientCertificate?: boolean;
+    clientCertificateCN?: string;
+  }
+
+  export interface Certificate {
+    private: string;
+    public: string;
+    cert: string;
+    fingerprint: string;
+  }
+
+  export function generate(attrs?: Attributes, options?: Options): Certificate;
+  export function generate(
+    attrs: Attributes,
+    options: Options,
+    callback: (err: Error, certificate: Certificate) => void
+  ): void;
+}

package/src/sites.tsx

@@ -1,34 +1,35 @@
+import assert from "node:assert";
 import { readdir, readFile, stat } from "node:fs/promises";
 import * as path from "node:path";
 import ignore from "ignore";
 import xxhash from "xxhash-wasm";
 import {
-  createNamespace,
-  listNamespaceKeys,
-  listNamespaces,
-  putBulkKeyValue,
+  createKVNamespace,
+  listKVNamespaceKeys,
+  listKVNamespaces,
+  putKVBulkKeyValue,
+  deleteKVBulkKeyValue,
 } from "./kv";
+import { logger } from "./logger";
 import type { Config } from "./config";
+import type { KeyValue } from "./kv";
 import type { XXHashAPI } from "xxhash-wasm";
 
 /** Paths to always ignore. */
-const ALWAYS_IGNORE = ["node_modules"];
-const HIDDEN_FILES_TO_INCLUDE = [
+const ALWAYS_IGNORE = new Set(["node_modules"]);
+const HIDDEN_FILES_TO_INCLUDE = new Set([
   ".well-known", // See https://datatracker.ietf.org/doc/html/rfc8615
-];
+]);
 
 async function* getFilesInFolder(dirPath: string): AsyncIterable<string> {
   const files = await readdir(dirPath, { withFileTypes: true });
   for (const file of files) {
     // Skip files that we never want to process.
-    if (ALWAYS_IGNORE.some((p) => file.name === p)) {
+    if (ALWAYS_IGNORE.has(file.name)) {
       continue;
     }
     // Skip hidden files (starting with .) except for some special ones
-    if (
-      file.name.startsWith(".") &&
-      !HIDDEN_FILES_TO_INCLUDE.some((p) => file.name === p)
-    ) {
+    if (file.name.startsWith(".") && !HIDDEN_FILES_TO_INCLUDE.has(file.name)) {
       continue;
     }
     // TODO: follow symlinks??
@@ -75,15 +76,15 @@ async function createKVNamespaceIfNotAlreadyExisting(
 ) {
   // check if it already exists
   // TODO: this is super inefficient, should be made better
-  const namespaces = await listNamespaces(accountId);
+  const namespaces = await listKVNamespaces(accountId);
   const found = namespaces.find((x) => x.title === title);
   if (found) {
     return { created: false, id: found.id };
   }
 
   // else we make the namespace
-  const id = await createNamespace(accountId, title);
-  console.log(`🌀 Created namespace for Workers Site "${title}"`);
+  const id = await createKVNamespace(accountId, title);
+  logger.log(`🌀 Created namespace for Workers Site "${title}"`);
 
   return {
     created: true,
@@ -103,10 +104,11 @@ async function createKVNamespaceIfNotAlreadyExisting(
  * asset in the KV namespace.
  */
 export async function syncAssets(
-  accountId: string,
+  accountId: string | undefined,
   scriptName: string,
   siteAssets: AssetPaths | undefined,
-  preview: boolean
+  preview: boolean,
+  dryRun: boolean | undefined
 ): Promise<{
   manifest: { [filePath: string]: string } | undefined;
   namespace: string | undefined;
@@ -115,59 +117,113 @@ export async function syncAssets(
     return { manifest: undefined, namespace: undefined };
   }
 
+  if (dryRun) {
+    logger.log("(Note: doing a dry run, not uploading or deleting anything.)");
+    return { manifest: undefined, namespace: undefined };
+  }
+  assert(accountId, "Missing accountId");
+
   const title = `__${scriptName}-workers_sites_assets${
     preview ? "_preview" : ""
   }`;
+
   const { id: namespace } = await createKVNamespaceIfNotAlreadyExisting(
     title,
     accountId
   );
 
   // let's get all the keys in this namespace
-  const result = await listNamespaceKeys(accountId, namespace);
-  const keys = new Set(result.map((x) => x.name));
+  const namespaceKeysResponse = await listKVNamespaceKeys(accountId, namespace);
+  const namespaceKeys = new Set(namespaceKeysResponse.map((x) => x.name));
 
   const manifest: Record<string, string> = {};
-  const upload: {
-    key: string;
-    value: string;
-    base64: boolean;
-  }[] = [];
+
+  // A batch of uploads where each bucket has to be less than 100mb
+  const uploadBuckets: KeyValue[][] = [];
+  // The "live" bucket that we'll keep filling until it's just below 100mb
+  let uploadBucket: KeyValue[] = [];
+  // A size counter for the live bucket
+  let uploadBucketSize = 0;
 
   const include = createPatternMatcher(siteAssets.includePatterns, false);
   const exclude = createPatternMatcher(siteAssets.excludePatterns, true);
   const hasher = await xxhash();
 
-  // TODO: this can be more efficient by parallelising
-  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(assetDirectory, 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");
-
-    const assetKey = await hashAsset(hasher, file, content);
+    logger.log(`Reading ${assetFile}...`);
+    const content = await readFile(absAssetFile, "base64");
+    await validateAssetSize(absAssetFile, assetFile);
+    // while KV accepts files that are 25 MiB **before** b64 encoding
+    // the overall bucket size must be below 100 MiB **after** b64 encoding
+    const assetSize = Buffer.from(content).length;
+    const assetKey = hashAsset(hasher, assetFile, content);
     validateAssetKey(assetKey);
 
     // now put each of the files into kv
-    if (!keys.has(assetKey)) {
-      console.log(`uploading as ${assetKey}...`);
-      upload.push({
+    if (!namespaceKeys.has(assetKey)) {
+      logger.log(`Uploading as ${assetKey}...`);
+
+      // Check if adding this asset to the bucket would
+      // push it over the 100 MiB limit KV bulk API limit
+      if (uploadBucketSize + assetSize > 100 * 1024 * 1024) {
+        // If so, move the current bucket into the batch,
+        // and reset the counter/bucket
+        uploadBuckets.push(uploadBucket);
+        uploadBucketSize = 0;
+        uploadBucket = [];
+      }
+
+      // Update the bucket and the size counter
+      uploadBucketSize += assetSize;
+      uploadBucket.push({
         key: assetKey,
         value: content,
         base64: true,
       });
     } else {
-      console.log(`skipping - already uploaded`);
+      logger.log(`Skipping - already uploaded.`);
     }
-    manifest[path.relative(siteAssets.baseDirectory, file)] = assetKey;
+
+    // Remove the key from the set so we know what we've already uploaded
+    namespaceKeys.delete(assetKey);
+
+    // Prevent different manifest keys on windows
+    const manifestKey = urlSafe(path.relative(assetDirectory, absAssetFile));
+    manifest[manifestKey] = assetKey;
   }
-  await putBulkKeyValue(accountId, namespace, JSON.stringify(upload));
+
+  // Add the last (potentially only) bucket to the batch
+  uploadBuckets.push(uploadBucket);
+
+  // keys now contains all the files we're deleting
+  for (const key of namespaceKeys) {
+    logger.log(`Deleting ${key} from the asset store...`);
+  }
+
+  // upload each bucket in parallel
+  const bucketsToPut = [];
+  for (const bucket of uploadBuckets) {
+    bucketsToPut.push(putKVBulkKeyValue(accountId, namespace, bucket));
+  }
+  await Promise.all(bucketsToPut);
+
+  // then delete all the assets that aren't used anymore
+  await deleteKVBulkKeyValue(accountId, namespace, Array.from(namespaceKeys));
+
+  logger.log("↗️  Done syncing assets");
+
   return { manifest, namespace };
 }
 
@@ -183,11 +239,20 @@ function createPatternMatcher(
   }
 }
 
-async function validateAssetSize(filePath: string) {
-  const { size } = await stat(filePath);
+/**
+ * validate that the passed-in file is below 25 MiB
+ * **PRIOR** to base64 encoding. 25 MiB is a KV limit
+ * @param absFilePath
+ * @param relativeFilePath
+ */
+async function validateAssetSize(
+  absFilePath: string,
+  relativeFilePath: string
+): Promise<void> {
+  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`
     );
   }
 }
@@ -213,8 +278,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[];
 }
 
@@ -227,13 +307,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
+): AssetPaths | undefined {
+  const baseDirectory = path.resolve(
+    path.dirname(config.configPath ?? "wrangler.toml")
+  );
+
+  return assetDirectory
     ? {
         baseDirectory,
+        assetDirectory,
         includePatterns,
         excludePatterns,
       }

package/src/tail/index.ts

@@ -161,7 +161,7 @@ export type TailEventMessage = {
    * Any logs sent out by the worker
    */
   logs: {
-    message: unknown;
+    message: unknown[];
     level: string; // TODO: make this a union of possible values
     timestamp: number;
   }[];
@@ -179,7 +179,7 @@ export type TailEventMessage = {
    * Until workers-types exposes individual types for export, we'll have
    * to just re-define these types ourselves.
    */
-  event: RequestEvent | ScheduledEvent;
+  event: RequestEvent | ScheduledEvent | undefined | null;
 };
 
 /**

package/src/tail/printing.ts

@@ -1,3 +1,4 @@
+import { logger } from "../logger";
 import type { RequestEvent, ScheduledEvent, TailEventMessage } from ".";
 import type { Outcome } from "./filters";
 import type WebSocket from "ws";
@@ -12,25 +13,29 @@ export function prettyPrintLogs(data: WebSocket.RawData): void {
     ).toLocaleString();
     const outcome = prettifyOutcome(eventMessage.outcome);
 
-    console.log(`"${cronPattern}" @ ${datetime} - ${outcome}`);
+    logger.log(`"${cronPattern}" @ ${datetime} - ${outcome}`);
   } else {
-    const requestMethod = eventMessage.event.request.method.toUpperCase();
-    const url = eventMessage.event.request.url;
+    const requestMethod = eventMessage.event?.request.method.toUpperCase();
+    const url = eventMessage.event?.request.url;
     const outcome = prettifyOutcome(eventMessage.outcome);
     const datetime = new Date(eventMessage.eventTimestamp).toLocaleString();
 
-    console.log(`${requestMethod} ${url} - ${outcome} @ ${datetime}`);
+    logger.log(
+      url
+        ? `${requestMethod} ${url} - ${outcome} @ ${datetime}`
+        : `[missing request] - ${outcome} @ ${datetime}`
+    );
   }
 
   if (eventMessage.logs.length > 0) {
     eventMessage.logs.forEach(({ level, message }) => {
-      console.log(`  (${level}) ${message}`);
+      logger.log(`  (${level})`, ...message);
     });
   }
 
   if (eventMessage.exceptions.length > 0) {
     eventMessage.exceptions.forEach(({ name, message }) => {
-      console.error(`  ${name}: ${message}`);
+      logger.error(`  ${name}:`, message);
     });
   }
 }
@@ -40,9 +45,9 @@ export function jsonPrintLogs(data: WebSocket.RawData): void {
 }
 
 function isScheduledEvent(
-  event: RequestEvent | ScheduledEvent
+  event: RequestEvent | ScheduledEvent | undefined | null
 ): event is ScheduledEvent {
-  return "cron" in event;
+  return Boolean(event && "cron" in event);
 }
 
 function prettifyOutcome(outcome: Outcome): string {

package/src/update-check.ts

@@ -0,0 +1,19 @@
+import chalk from "chalk";
+import checkForUpdate from "update-check";
+import pkg from "../package.json";
+
+export async function updateCheck(): Promise<string> {
+  let update = null;
+  try {
+    // default cache for update check is 1 day
+    update = await checkForUpdate(pkg, {
+      distTag: pkg.version.startsWith("0.0.0") ? "beta" : "latest",
+    });
+  } catch (err) {
+    // ignore error
+  }
+
+  if (update) return `(update available ${chalk.green(update.latest)})`;
+
+  return "";
+}