wrangler 0.0.0-e3e3243 → 0.0.0-e41c7e41

package/pages/functions/template-worker.ts

@@ -1,130 +0,0 @@
-import { match } from "path-to-regexp";
-import type { HTTPMethod } from "./routes";
-
-/* TODO: Grab these from @cloudflare/workers-types instead */
-type Params<P extends string = string> = Record<P, string | string[]>;
-
-type EventContext<Env, P extends string, Data> = {
-  request: Request;
-  waitUntil: (promise: Promise<unknown>) => void;
-  next: (input?: Request | string, init?: RequestInit) => Promise<Response>;
-  env: Env & { ASSETS: { fetch: typeof fetch } };
-  params: Params<P>;
-  data: Data;
-};
-
-declare type PagesFunction<
-  Env = unknown,
-  P extends string = string,
-  Data extends Record<string, unknown> = Record<string, unknown>
-> = (context: EventContext<Env, P, Data>) => Response | Promise<Response>;
-/* end @cloudflare/workers-types */
-
-type RouteHandler = {
-  routePath: string;
-  method?: HTTPMethod;
-  modules: PagesFunction[];
-  middlewares: PagesFunction[];
-};
-
-// inject `routes` via ESBuild
-declare const routes: RouteHandler[];
-// define `__FALLBACK_SERVICE__` via ESBuild
-declare const __FALLBACK_SERVICE__: string;
-
-// expect an ASSETS fetcher binding pointing to the asset-server stage
-type FetchEnv = {
-  [name: string]: { fetch: typeof fetch };
-  ASSETS: { fetch: typeof fetch };
-};
-
-type WorkerContext = {
-  waitUntil: (promise: Promise<unknown>) => void;
-};
-
-function* executeRequest(request: Request, _env: FetchEnv) {
-  const requestPath = new URL(request.url).pathname;
-
-  // First, iterate through the routes (backwards) and execute "middlewares" on partial route matches
-  for (const route of [...routes].reverse()) {
-    if (route.method && route.method !== request.method) {
-      continue;
-    }
-
-    const routeMatcher = match(route.routePath, { end: false });
-    const matchResult = routeMatcher(requestPath);
-    if (matchResult) {
-      for (const handler of route.middlewares.flat()) {
-        yield {
-          handler,
-          params: matchResult.params as Params,
-        };
-      }
-    }
-  }
-
-  // Then look for the first exact route match and execute its "modules"
-  for (const route of routes) {
-    if (route.method && route.method !== request.method) {
-      continue;
-    }
-
-    const routeMatcher = match(route.routePath, { end: true });
-    const matchResult = routeMatcher(requestPath);
-    if (matchResult && route.modules.length) {
-      for (const handler of route.modules.flat()) {
-        yield {
-          handler,
-          params: matchResult.params as Params,
-        };
-      }
-      break;
-    }
-  }
-}
-
-export default {
-  async fetch(request: Request, env: FetchEnv, workerContext: WorkerContext) {
-    const handlerIterator = executeRequest(request, env);
-    const data = {}; // arbitrary data the user can set between functions
-    const next = async (input?: RequestInfo, init?: RequestInit) => {
-      if (input !== undefined) {
-        request = new Request(input, init);
-      }
-
-      const result = handlerIterator.next();
-      // Note we can't use `!result.done` because this doesn't narrow to the correct type
-      if (result.done == false) {
-        const { handler, params } = result.value;
-        const context = {
-          request: new Request(request.clone()),
-          next,
-          params,
-          data,
-          env,
-          waitUntil: workerContext.waitUntil.bind(workerContext),
-        };
-
-        const response = await handler(context);
-
-        // https://fetch.spec.whatwg.org/#null-body-status
-        return new Response(
-          [101, 204, 205, 304].includes(response.status) ? null : response.body,
-          response
-        );
-      } else if (__FALLBACK_SERVICE__) {
-        // There are no more handlers so finish with the fallback service (`env.ASSETS.fetch` in Pages' case)
-        return env[__FALLBACK_SERVICE__].fetch(request);
-      } else {
-        // There was not fallback service so actually make the request to the origin.
-        return fetch(request);
-      }
-    };
-
-    try {
-      return next();
-    } catch (err) {
-      return new Response("Internal Error", { status: 500 });
-    }
-  },
-};

package/src/__tests__/helpers/faye-websocket.d.ts

@@ -1,6 +0,0 @@
-module "faye-websocket" {
-  /**
-   * Standards-compliant WebSocket client and server.
-   */
-  export default WebSocket;
-}

package/src/__tests__/logout.test.ts

@@ -1,52 +0,0 @@
-import { existsSync } from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import fetchMock from "jest-fetch-mock";
-import {
-  reinitialiseAuthTokens,
-  USER_AUTH_CONFIG_FILE,
-  writeAuthConfigFile,
-} from "../user";
-import { mockConsoleMethods } from "./helpers/mock-console";
-import { runInTempDir } from "./helpers/run-in-tmp";
-import { runWrangler } from "./helpers/run-wrangler";
-
-describe("wrangler", () => {
-  runInTempDir({ homedir: "./home" });
-  const std = mockConsoleMethods();
-
-  describe("logout", () => {
-    it("should exit with a message stating the user is not logged in", async () => {
-      await runWrangler("logout");
-      expect(std.out).toMatchInlineSnapshot(`"Not logged in, exiting..."`);
-    });
-
-    it("should logout user that has been properly logged in", async () => {
-      writeAuthConfigFile({
-        oauth_token: "some-oauth-tok",
-        refresh_token: "some-refresh-tok",
-      });
-      // Mock out the response for a request to revoke the auth tokens,
-      // checking the form of the request is as expected.
-      fetchMock.mockResponseOnce(async (req) => {
-        expect(req.url).toEqual("https://dash.cloudflare.com/oauth2/revoke");
-        expect(req.method).toEqual("POST");
-        return "";
-      });
-
-      // Now that we have changed the auth tokens in the wrangler.toml we must reinitialize the user auth state.
-      reinitialiseAuthTokens();
-      await runWrangler("logout");
-
-      expect(std.out).toMatchInlineSnapshot(`"Successfully logged out."`);
-
-      // Make sure that we made the request to logout.
-      expect(fetchMock).toHaveBeenCalledTimes(1);
-
-      // Make sure that logout removed the config file containing the auth tokens.
-      expect(existsSync(path.join(os.homedir(), USER_AUTH_CONFIG_FILE))).toBe(
-        false
-      );
-    });
-  });
-});

package/src/__tests__/sentry.test.ts

@@ -1,146 +0,0 @@
-import * as fs from "node:fs";
-import * as fsp from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import * as TOML from "@iarna/toml";
-import * as Sentry from "@sentry/node";
-import prompts from "prompts";
-
-import { mockConsoleMethods } from "./helpers/mock-console";
-import { runInTempDir } from "./helpers/run-in-tmp";
-import { runWrangler } from "./helpers/run-wrangler";
-const { reportError } = jest.requireActual("../reporting");
-
-describe("Error Reporting", () => {
-  runInTempDir({ homedir: "./home" });
-  mockConsoleMethods();
-  const reportingTOMLPath = ".wrangler/config/reporting.toml";
-
-  const originalTTY = process.stdout.isTTY;
-  beforeEach(() => {
-    jest.mock("@sentry/node");
-    jest.spyOn(Sentry, "captureException");
-    process.stdout.isTTY = true;
-  });
-
-  afterEach(() => {
-    jest.unmock("@sentry/node");
-    jest.clearAllMocks();
-    process.stdout.isTTY = originalTTY;
-  });
-
-  it("should confirm user will allow error reporting usage", async () => {
-    jest.spyOn(prompts, "prompt").mockResolvedValue({ sentryDecision: true });
-
-    await reportError(new Error("test error"), "testFalse");
-
-    const { error_tracking_opt, error_tracking_opt_date } = TOML.parse(
-      await fsp.readFile(path.join(os.homedir(), reportingTOMLPath), "utf-8")
-    );
-
-    expect(error_tracking_opt).toBe(true);
-    expect(error_tracking_opt_date).toBeTruthy();
-
-    expect(Sentry.captureException).toHaveBeenCalledWith(
-      new Error("test error")
-    );
-  });
-
-  it("should confirm user will disallow error reporting usage", async () => {
-    jest.spyOn(prompts, "prompt").mockResolvedValue({ sentryDecision: false });
-    await reportError(new Error("test error"), "testFalse");
-
-    const { error_tracking_opt, error_tracking_opt_date } = TOML.parse(
-      await fsp.readFile(path.join(os.homedir(), reportingTOMLPath), "utf-8")
-    );
-
-    expect(error_tracking_opt).toBe(false);
-    expect(error_tracking_opt_date).toBeTruthy();
-
-    expect(Sentry.captureException).not.toHaveBeenCalledWith(
-      new Error("test error"),
-      "testFalse"
-    );
-  });
-
-  it("should confirm user will allow 'once' error reporting usage", async () => {
-    jest.spyOn(prompts, "prompt").mockResolvedValue({ sentryDecision: "once" });
-    await runWrangler();
-    await reportError(new Error("test error"), "testFalse");
-
-    expect(fs.existsSync(path.join(os.homedir(), reportingTOMLPath))).toBe(
-      false
-    );
-
-    expect(Sentry.captureException).not.toHaveBeenCalledWith(
-      new Error("test error"),
-      "testFalse"
-    );
-  });
-
-  it("should not prompt w/ subsequent Errors after user disallows error reporting", async () => {
-    jest.spyOn(prompts, "prompt").mockResolvedValue({ sentryDecision: false });
-    await reportError(new Error("test error"), "testFalse");
-
-    expect(Sentry.captureException).not.toHaveBeenCalledWith(
-      new Error("test error"),
-      "testFalse"
-    );
-
-    await reportError(new Error("second test error"), "testFalse");
-    expect(Sentry.captureException).not.toHaveBeenCalledWith(
-      new Error("second test error"),
-      "testFalse"
-    );
-  });
-
-  it("should not prompt w/ subsequent Errors after user Always allows error reporting", async () => {
-    jest.spyOn(prompts, "prompt").mockResolvedValue({ sentryDecision: true });
-    await reportError(new Error("test error"), "testFalse");
-
-    expect(Sentry.captureException).toHaveBeenCalledWith(
-      new Error("test error")
-    );
-
-    await reportError(new Error("second test error"), "testFalse");
-    expect(Sentry.captureException).toHaveBeenCalledWith(
-      new Error("second test error")
-    );
-  });
-
-  it("should prompt w/ subsequent Errors after user allows error reporting once", async () => {
-    const promptSpy = jest
-      .spyOn(prompts, "prompt")
-      .mockResolvedValue({ sentryDecision: "once" });
-    await reportError(new Error("test error"), "testFalse");
-
-    expect(Sentry.captureException).toHaveBeenCalledWith(
-      new Error("test error")
-    );
-
-    await reportError(new Error("second test error"), "testFalse");
-    expect(Sentry.captureException).toHaveBeenCalledWith(
-      new Error("second test error")
-    );
-
-    expect(promptSpy).toBeCalledTimes(2);
-  });
-
-  it("should not prompt in non-TTY environment", async () => {
-    process.stdout.isTTY = false;
-
-    await reportError(new Error("test error"), "testFalse");
-
-    const { error_tracking_opt, error_tracking_opt_date } = TOML.parse(
-      await fsp.readFile(path.join(os.homedir(), reportingTOMLPath), "utf-8")
-    );
-
-    expect(error_tracking_opt).toBe(false);
-    expect(error_tracking_opt_date).toBeTruthy();
-
-    expect(Sentry.captureException).not.toHaveBeenCalledWith(
-      new Error("test error")
-    );
-    process.stdout.isTTY = originalTTY;
-  });
-});

package/src/kv.ts

@@ -1,319 +0,0 @@
-import { URLSearchParams } from "node:url";
-import { fetchListResult, fetchResult, fetchKVGetValue } from "./cfetch";
-import type { Config } from "./config";
-
-/** The largest number of kv items we can pass to the API in a single request. */
-const API_MAX = 10000;
-// The const below are halved from the API's true capacity to help avoid
-// hammering it with large requests.
-const BATCH_KEY_MAX = API_MAX / 2;
-
-type KvArgs = {
-  binding?: string;
-  "namespace-id"?: string;
-  preview?: boolean;
-};
-
-/**
- * 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.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 = ""
-) {
-  return await fetchListResult<NamespaceKeyInfo>(
-    `/accounts/${accountId}/storage/kv/namespaces/${namespaceId}/keys`,
-    {},
-    new URLSearchParams({ prefix })
-  );
-}
-
-/**
- * Information about a key-value pair, including its "metadata" fields.
- */
-export interface KeyValue {
-  key: string;
-  value: string;
-  expiration?: number;
-  expiration_ttl?: number;
-  metadata?: object;
-  base64?: boolean;
-}
-
-const KeyValueKeys = new Set([
-  "key",
-  "value",
-  "expiration",
-  "expiration_ttl",
-  "metadata",
-  "base64",
-]);
-
-/**
- * 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")) {
-    return false;
-  }
-  return true;
-}
-
-/**
- * Get all the properties on the `keyValue` that are not expected.
- */
-export function unexpectedKeyValueProps(keyValue: KeyValue): string[] {
-  const props = Object.keys(keyValue);
-  return props.filter((prop) => !KeyValueKeys.has(prop));
-}
-
-export async function putKeyValue(
-  accountId: string,
-  namespaceId: string,
-  keyValue: KeyValue
-) {
-  let searchParams: URLSearchParams | undefined;
-  if (keyValue.expiration || keyValue.expiration_ttl) {
-    searchParams = new URLSearchParams();
-    if (keyValue.expiration) {
-      searchParams.set("expiration", `${keyValue.expiration}`);
-    }
-    if (keyValue.expiration_ttl) {
-      searchParams.set("expiration_ttl", `${keyValue.expiration_ttl}`);
-    }
-  }
-  return await fetchResult(
-    `/accounts/${accountId}/storage/kv/namespaces/${namespaceId}/values/${keyValue.key}`,
-    { method: "PUT", body: keyValue.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,
-  keyValues: KeyValue[],
-  progressCallback: (index: number, total: number) => void
-) {
-  for (let index = 0; index < keyValues.length; index += BATCH_KEY_MAX) {
-    if (progressCallback && keyValues.length > BATCH_KEY_MAX) {
-      progressCallback(index, keyValues.length);
-    }
-
-    await fetchResult(
-      `/accounts/${accountId}/storage/kv/namespaces/${namespaceId}/bulk`,
-      {
-        method: "PUT",
-        body: JSON.stringify(keyValues.slice(index, index + BATCH_KEY_MAX)),
-        headers: { "Content-Type": "application/json" },
-      }
-    );
-  }
-  if (progressCallback && keyValues.length > BATCH_KEY_MAX) {
-    progressCallback(keyValues.length, keyValues.length);
-  }
-}
-
-export async function deleteBulkKeyValue(
-  accountId: string,
-  namespaceId: string,
-  keys: string[],
-  progressCallback: (index: number, total: number) => void
-) {
-  for (let index = 0; index < keys.length; index += BATCH_KEY_MAX) {
-    if (progressCallback && keys.length > BATCH_KEY_MAX) {
-      progressCallback(index, keys.length);
-    }
-
-    await fetchResult(
-      `/accounts/${accountId}/storage/kv/namespaces/${namespaceId}/bulk`,
-      {
-        method: "DELETE",
-        body: JSON.stringify(keys.slice(index, index + BATCH_KEY_MAX)),
-        headers: { "Content-Type": "application/json" },
-      }
-    );
-  }
-  if (progressCallback && keys.length > BATCH_KEY_MAX) {
-    progressCallback(keys.length, keys.length);
-  }
-}
-
-export function getNamespaceId(
-  { preview, binding, "namespace-id": namespaceId }: KvArgs,
-  config: Config
-): string {
-  // nice
-  if (namespaceId) {
-    return namespaceId;
-  }
-
-  // begin pre-flight checks
-
-  // `--binding` is only valid if there's a wrangler configuration.
-  if (binding && !config) {
-    throw new Error("--binding specified, but no config file was found.");
-  }
-
-  // there's no config. abort here
-  if (!config) {
-    throw new Error(
-      "Failed to find a config file.\n" +
-        "Either use --namespace-id to upload directly or create a configuration file with a binding."
-    );
-  }
-
-  // there's no KV namespaces
-  if (!config.kv_namespaces || config.kv_namespaces.length === 0) {
-    throw new Error(
-      "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((ns) => ns.binding === binding);
-
-  // we couldn't find a namespace with that binding
-  if (!namespace) {
-    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 `--preview` was passed
-  if (preview && namespace.preview_id) {
-    namespaceId = namespace.preview_id;
-    // 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.`
-    );
-  }
-
-  // either `--preview false`, or preview wasn't passed
-  // TODO: should we care? or should we just treat false and undefined the same
-  const previewIsDefined = typeof preview !== "undefined";
-
-  // --preview false was passed
-  if (previewIsDefined && namespace.id) {
-    namespaceId = namespace.id;
-    // 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.`
-    );
-  }
-
-  // `--preview` wasn't passed
-  const bindingHasOnlyOneId =
-    (namespace.id && !namespace.preview_id) ||
-    (!namespace.id && namespace.preview_id);
-  if (bindingHasOnlyOneId) {
-    namespaceId = namespace.id || namespace.preview_id;
-  } else {
-    throw new Error(
-      `${binding} has both a namespace ID and a preview ID. Specify "--preview" or "--preview false" to avoid writing data to the wrong namespace.`
-    );
-  }
-
-  // shouldn't happen. we should be able to prove this with strong typing.
-  // TODO: when we add strongly typed commands, rewrite these checks so they're exhaustive
-  if (!namespaceId) {
-    throw Error(
-      "Something went wrong trying to determine which namespace to upload to.\n" +
-        "Please create a github issue with the command you just ran along with your wrangler configuration."
-    );
-  }
-
-  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/miniflare-cli/enum-keys.ts

@@ -1,17 +0,0 @@
-export type EnumKeys<Enum> = Exclude<keyof Enum, number>;
-
-export const enumObject = <Enum extends Record<string, number | string>>(
-  e: Enum
-) => {
-  const copy = { ...e } as { [K in EnumKeys<Enum>]: Enum[K] };
-  Object.values(e).forEach(
-    (value) => typeof value === "number" && delete copy[value]
-  );
-  return copy;
-};
-
-export const enumKeys = <Enum extends Record<string, number | string>>(
-  e: Enum
-) => {
-  return Object.keys(enumObject(e)) as EnumKeys<Enum>[];
-};