wrangler 0.0.0-e452a04 → 0.0.0-e464fcdb

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__/dev2.test.tsx

@@ -1,152 +0,0 @@
-import * as fs from "node:fs";
-import React from "react";
-import TestRenderer from "react-test-renderer";
-import { mockAccountId, mockApiToken } from "./helpers/mock-account-id";
-import { unsetAllMocks } from "./helpers/mock-cfetch";
-import { mockConsoleMethods } from "./helpers/mock-console";
-import { runInTempDir } from "./helpers/run-in-tmp";
-import type { DevProps, default as DevType } from "../dev/dev";
-
-function sleep(period = 100): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, period));
-}
-
-// we use this ["mock"] form to avoid esbuild-jest from rewriting it
-jest["mock"]("../proxy", () => {
-  return {
-    usePreviewServer() {},
-    waitForPortToBeAvailable() {},
-  };
-});
-jest["mock"]("../inspect", () => {
-  return () => {};
-});
-
-const Dev: typeof DevType = jest.requireActual("../dev/dev").DevImplementation;
-
-mockAccountId();
-mockApiToken();
-runInTempDir();
-mockConsoleMethods();
-afterEach(() => {
-  unsetAllMocks();
-});
-
-describe("dev", () => {
-  it("should render", async () => {
-    fs.writeFileSync("./index.js", `export default {}`);
-
-    const testRenderer = await renderDev({
-      entry: {
-        file: "./index.js",
-        directory: process.cwd(),
-        format: "modules",
-      },
-    });
-    expect(testRenderer.toJSON()).toMatchInlineSnapshot(`
-      <ink-box
-        style={
-          Object {
-            "borderStyle": "round",
-            "flexDirection": "row",
-            "flexGrow": 0,
-            "flexShrink": 1,
-            "marginBottom": 0,
-            "marginLeft": 0,
-            "marginRight": 0,
-            "marginTop": 0,
-            "paddingBottom": 0,
-            "paddingLeft": 1,
-            "paddingRight": 1,
-            "paddingTop": 0,
-          }
-        }
-      >
-        <ink-text
-          internal_transform={[Function]}
-          style={
-            Object {
-              "flexDirection": "row",
-              "flexGrow": 0,
-              "flexShrink": 1,
-              "textWrap": "wrap",
-            }
-          }
-        >
-          B to open a browser, D to open Devtools, L to turn off local mode, X to exit
-        </ink-text>
-      </ink-box>
-    `);
-    await TestRenderer.act(async () => {
-      // TODO: get rid of these sleep statements
-      await sleep(50);
-      testRenderer.unmount();
-      await sleep(50);
-    });
-    await sleep(50);
-  });
-});
-
-async function renderDev({
-  name,
-  entry = { file: "index.js", directory: "", format: "modules" },
-  port,
-  inspectorPort = 9229,
-  accountId,
-  legacyEnv = true,
-  initialMode = "local",
-  jsxFactory,
-  jsxFragment,
-  localProtocol = "http",
-  upstreamProtocol = "https",
-  rules = [],
-  bindings = {
-    kv_namespaces: [],
-    vars: {},
-    durable_objects: { bindings: [] },
-    r2_buckets: [],
-    wasm_modules: undefined,
-    text_blobs: undefined,
-    unsafe: [],
-  },
-  public: publicDir,
-  assetPaths,
-  compatibilityDate,
-  compatibilityFlags,
-  usageModel,
-  buildCommand = {},
-  enableLocalPersistence = false,
-  env,
-  zone,
-}: Partial<DevProps>): Promise<TestRenderer.ReactTestRenderer> {
-  let instance: TestRenderer.ReactTestRenderer | undefined;
-  await TestRenderer.act(async () => {
-    instance = TestRenderer.create(
-      <Dev
-        name={name}
-        entry={entry}
-        env={env}
-        rules={rules}
-        port={port}
-        inspectorPort={inspectorPort}
-        legacyEnv={legacyEnv}
-        buildCommand={buildCommand}
-        initialMode={initialMode}
-        localProtocol={localProtocol}
-        upstreamProtocol={upstreamProtocol}
-        jsxFactory={jsxFactory}
-        jsxFragment={jsxFragment}
-        accountId={accountId}
-        assetPaths={assetPaths}
-        public={publicDir}
-        compatibilityDate={compatibilityDate}
-        compatibilityFlags={compatibilityFlags}
-        usageModel={usageModel}
-        bindings={bindings}
-        enableLocalPersistence={enableLocalPersistence}
-        zone={zone}
-      />
-    );
-  });
-  return instance as TestRenderer.ReactTestRenderer;
-}

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__/helpers/mock-cfetch.ts

@@ -1,207 +0,0 @@
-import { URL, URLSearchParams } from "node:url";
-import { pathToRegexp } from "path-to-regexp";
-import { getCloudflareApiBaseUrl } from "../../cfetch";
-import type { FetchResult, FetchError } from "../../cfetch";
-import type { RequestInit } from "undici";
-
-/**
- * The signature of the function that will handle a mock request.
- */
-export type MockHandler<ResponseType> = (
-  uri: RegExpExecArray,
-  init: RequestInit,
-  queryParams: URLSearchParams
-) => ResponseType | Promise<ResponseType>;
-
-type RemoveMockFn = () => void;
-
-interface MockFetch<ResponseType> {
-  regexp: RegExp;
-  method: string | undefined;
-  handler: MockHandler<ResponseType>;
-}
-const mocks: MockFetch<unknown>[] = [];
-
-/**
- * The mock implementation of `cfApi.fetch()`.
- *
- * This function will attempt to match the given request to one of the mock handlers configured by calls to `setMock`.
- *
- * Once found the handler will be used to generate a mock response.
- */
-export async function mockFetchInternal(
-  resource: string,
-  init: RequestInit = {},
-  queryParams: URLSearchParams = new URLSearchParams()
-) {
-  for (const { regexp, method, handler } of mocks) {
-    const resourcePath = new URL(resource, getCloudflareApiBaseUrl()).pathname;
-    const uri = regexp.exec(resourcePath);
-    // Do the resource path and (if specified) the HTTP method match?
-    if (uri !== null && (!method || method === (init.method ?? "GET"))) {
-      // The `resource` regular expression will extract the labelled groups from the URL.
-      // These are passed through to the `handler` call, to allow it to do additional checks or behaviour.
-      return await handler(uri, init, queryParams); // TODO: should we have some kind of fallthrough system? we'll see.
-    }
-  }
-  throw new Error(
-    `no mocks found for ${init.method ?? "any HTTP"} request to ${resource}`
-  );
-}
-
-/**
- * Specify an expected resource path that is to be handled, resulting in a raw JSON response.
- *
- * @param resource The path of the resource to be matched.
- * This can include wildcards whose value will be passed to the `handler`.
- * @param handler The function that will generate the mock response for this request.
- */
-export function setMockRawResponse<ResponseType>(
-  resource: string,
-  handler: MockHandler<ResponseType>
-): RemoveMockFn;
-/**
- * Specify an expected resource path that is to be handled, resulting in a raw JSON response.
- *
- * @param resource The path of the resource to be matched.
- * This can include wildcards whose value will be passed to the `handler`.
- * @param method The HTTP method (e.g. GET, POST, etc) that the request must have to match this mock handler.
- * @param handler The function that will generate the mock response for this request.
- */
-export function setMockRawResponse<ResponseType>(
-  resource: string,
-  method: string,
-  handler: MockHandler<ResponseType>
-): RemoveMockFn;
-/**
- * Specify an expected resource path that is to be handled, resulting in a raw JSON response.
- */
-export function setMockRawResponse<ResponseType>(
-  resource: string,
-  ...args: [string, MockHandler<ResponseType>] | [MockHandler<ResponseType>]
-): RemoveMockFn {
-  const handler = args.pop() as MockHandler<ResponseType>;
-  const method = args.pop() as string;
-  const mock = {
-    resource,
-    method,
-    handler,
-    regexp: pathToRegexp(resource),
-  };
-  mocks.push(mock);
-  return () => {
-    const mockIndex = mocks.indexOf(mock);
-    if (mockIndex !== -1) {
-      mocks.splice(mockIndex, 1);
-    }
-  };
-}
-
-/**
- * Specify an expected resource path that is to be handled, resulting in a `FetchRequest`.
- *
- * The mock `handler` should return the `result`, which will then be wrapped in a `FetchRequest` object.
- *
- * @param resource The path of the resource to be matched.
- * This can include wildcards whose value will be passed to the `handler`.
- * @param handler The function that will generate the mock response for this request.
- */
-export function setMockResponse<ResponseType>(
-  resource: string,
-  handler: MockHandler<ResponseType>
-): RemoveMockFn;
-/**
- * Specify an expected resource path that is to be handled, resulting in a FetchRequest..
- *
- * @param resource The path of the resource to be matched.
- * This can include wildcards whose value will be passed to the `handler`.
- * @param method The HTTP method (e.g. GET, POST, etc) that the request must have to match this mock handler.
- * @param handler The function that will generate the mock response for this request.
- */
-export function setMockResponse<ResponseType>(
-  resource: string,
-  method: string,
-  handler: MockHandler<ResponseType>
-): RemoveMockFn;
-/**
- * Specify an expected resource path that is to be handled, resulting in a FetchRequest.
- */
-export function setMockResponse<ResponseType>(
-  resource: string,
-  ...args: [string, MockHandler<ResponseType>] | [MockHandler<ResponseType>]
-): RemoveMockFn {
-  const handler = args.pop() as MockHandler<ResponseType>;
-  const method = args.pop() as string;
-  return setMockRawResponse(resource, method, (...handlerArgs) =>
-    createFetchResult(handler(...handlerArgs))
-  );
-}
-
-/**
- * A helper to make it easier to create `FetchResult` objects in tests.
- */
-export async function createFetchResult<ResponseType>(
-  result: ResponseType | Promise<ResponseType>,
-  success = true,
-  errors: FetchError[] = [],
-  messages: string[] = [],
-  result_info?: unknown
-): Promise<FetchResult<ResponseType>> {
-  return result_info
-    ? {
-        result: await result,
-        success,
-        errors,
-        messages,
-        result_info,
-      }
-    : {
-        result: await result,
-        success,
-        errors,
-        messages,
-      };
-}
-
-/**
- * Remove all the configured mock handlers.
- *
- * This should be called in an `afterEach()` block to ensure that mock handlers do not leak between tests.
- */
-export function unsetAllMocks() {
-  mocks.length = 0;
-}
-
-/**
- * We special-case fetching the request for `kv:key get`, because it's
- * the only cloudflare API endpoint that returns a plain string as the
- * value, and not as the "standard" FetchResult-style json. Hence, we also
- * special-case mocking it here.
- */
-
-const kvGetMocks = new Map<string, string>();
-
-export function mockFetchKVGetValue(
-  accountId: string,
-  namespaceId: string,
-  key: string
-) {
-  const mapKey = `${accountId}/${namespaceId}/${key}`;
-  if (kvGetMocks.has(mapKey)) {
-    return kvGetMocks.get(mapKey);
-  }
-  throw new Error(`no mock value found for \`kv:key get\` - ${mapKey}`);
-}
-
-export function setMockFetchKVGetValue(
-  accountId: string,
-  namespaceId: string,
-  key: string,
-  value: string
-) {
-  kvGetMocks.set(`${accountId}/${namespaceId}/${key}`, value);
-}
-
-export function unsetMockFetchKVGetValues() {
-  kvGetMocks.clear();
-}

package/src/__tests__/helpers/mock-user.ts

@@ -1,27 +0,0 @@
-import { mkdirSync, writeFileSync } from "node:fs";
-import os from "node:os";
-import path from "node:path";
-
-export function writeUserConfig(
-  oauth_token?: string,
-  refresh_token?: string,
-  expiration_time?: string
-) {
-  const lines: string[] = [];
-  if (oauth_token) {
-    lines.push(`oauth_token = "${oauth_token}"`);
-  }
-  if (refresh_token) {
-    lines.push(`refresh_token = "${refresh_token}"`);
-  }
-  if (expiration_time) {
-    lines.push(`expiration_time = "${expiration_time}"`);
-  }
-  const configPath = path.join(os.homedir(), ".wrangler/config");
-  mkdirSync(configPath, { recursive: true });
-  writeFileSync(
-    path.join(configPath, "default.toml"),
-    lines.join("\n"),
-    "utf-8"
-  );
-}

package/src/__tests__/pages.test.ts

@@ -1,44 +0,0 @@
-import { getPackageManager } from "../package-manager";
-import { mockConsoleMethods } from "./helpers/mock-console";
-import { runInTempDir } from "./helpers/run-in-tmp";
-import { runWrangler } from "./helpers/run-wrangler";
-import type { PackageManager } from "../package-manager";
-
-describe("subcommand implicit help ran on imcomplete command execution", () => {
-  let mockPackageManager: PackageManager;
-  runInTempDir();
-
-  beforeEach(() => {
-    mockPackageManager = {
-      cwd: process.cwd(),
-      // @ts-expect-error we're making a fake package manager here
-      type: "mockpm",
-      addDevDeps: jest.fn(),
-      install: jest.fn(),
-    };
-    (getPackageManager as jest.Mock).mockResolvedValue(mockPackageManager);
-  });
-
-  const std = mockConsoleMethods();
-  function endEventLoop() {
-    return new Promise((resolve) => setImmediate(resolve));
-  }
-  it("no subcommand for 'pages' should display a list of available subcommands", async () => {
-    await runWrangler("pages");
-    await endEventLoop();
-    expect(std.out).toMatchInlineSnapshot(`
-    "wrangler pages
-
-    ⚡️ Configure Cloudflare Pages
-
-    Commands:
-      wrangler pages dev [directory] [-- command]  🧑‍💻 Develop your full-stack Pages application locally
-
-    Flags:
-      -c, --config      Path to .toml configuration file  [string]
-      -h, --help        Show help  [boolean]
-      -v, --version     Show version number  [boolean]
-          --legacy-env  Use legacy environments  [boolean]"
-    `);
-  });
-});