wrangler 0.0.2 → 0.0.6

package/src/cfetch.ts

@@ -0,0 +1,72 @@
+import fetch from "node-fetch";
+import type { RequestInit } from "node-fetch";
+import { getAPIToken } from "./user";
+import { loginOrRefreshIfRequired } from "./user";
+
+export const CF_API_BASE_URL =
+  process.env.CF_API_BASE_URL || "https://api.cloudflare.com/client/v4";
+
+export default async function fetchWithAuthAndLoginIfRequired<ResponseType>(
+  resource: string,
+  init: RequestInit = {}
+): Promise<ResponseType> {
+  const loggedIn = await loginOrRefreshIfRequired();
+  if (!loggedIn) {
+    throw new Error("Not logged in");
+  }
+  const apiToken = getAPIToken();
+  if (!apiToken) {
+    throw new Error("No API token found");
+  }
+  // @ts-expect-error Authorization isn't non HeadersInit, annoyingly
+  if (init.headers?.Authorization) {
+    throw new Error(
+      "fetchWithAuthAndLoginIfRequired will not add an authorisation header a request that already specifies it"
+    );
+  }
+  // should I bother with response code?
+  // maybe I can just throw the json error?
+
+  const response = await fetch(`${CF_API_BASE_URL}${resource}`, {
+    method: "GET",
+    ...init,
+    headers: {
+      ...(init.headers || {}),
+      Authorization: `Bearer ${apiToken}`,
+    },
+  });
+  const text = await response.text();
+  let json;
+  try {
+    json = JSON.parse(text);
+  } catch (parseError) {
+    // hate this edge case
+    // the only api call I know that doesn't return json is kv:key get <key>
+
+    // maybe it's a plain response
+    if (response.ok) {
+      // @ts-expect-error bleh
+      return text;
+    } else {
+      // UGH.
+      throw new Error(`${response.status}: ${response.statusText}`);
+    }
+  }
+
+  if (json.success) {
+    return json.result;
+  } else {
+    const errorDesc = json.errors?.[0];
+    if (errorDesc) {
+      // TODO: map .message to real human readable strings
+      const error = new Error(`${errorDesc.code}: ${errorDesc.message}`);
+      // @ts-expect-error hacksss
+      error.code = errorDesc.code;
+      throw error;
+    } else {
+      // This should almost never happen.
+      // ... which means it'll probably happen, lol.
+      throw new Error(`${response.status}: ${response.statusText}`);
+    }
+  }
+}

package/src/cli.ts

@@ -0,0 +1,10 @@
+import { main } from ".";
+
+main(process.argv.slice(2)).catch((cause) => {
+  const { name, message } = cause;
+  if (name === "CloudflareError") {
+    console.error("\x1b[31m", message);
+    return;
+  }
+  throw cause;
+});

package/src/config.ts

@@ -0,0 +1,122 @@
+// we're going to manually write both the type definition AND
+// the validator for the config, so that we can give better error messages
+
+type DOMigration = {
+  tag: string;
+  new_classes?: string[];
+  renamed_classes?: string[];
+  deleted_classes?: string[];
+};
+
+type Project = "webpack" | "javascript" | "rust";
+
+type Site = {
+  // inherited
+  bucket: string;
+  "entry-point": string;
+  include?: string[];
+  exclude?: string[];
+};
+
+type Dev = {
+  ip?: string;
+  port?: number;
+  local_protocol?: string;
+  upstream_protocol?: string;
+};
+
+type Vars = { [key: string]: string };
+
+type Cron = string; // TODO: we should be able to parse a cron pattern with ts
+
+type KVNamespace = {
+  binding?: string;
+  preview_id: string;
+  id: string;
+};
+
+type DurableObject = {
+  name: string;
+  class_name: string;
+  script_name?: string;
+};
+
+type Build = {
+  command?: string;
+  cwd?: string;
+  watch_dir?: string;
+} & (
+  | {
+      upload?: {
+        format: "service-worker";
+        main: string;
+      };
+    }
+  | {
+      upload?: {
+        format: "modules";
+        dir?: string;
+        main?: string;
+        rules?: {
+          type: "ESModule" | "CommonJS" | "Text" | "Data" | "CompiledWasm";
+          globs: string[]; // can we use typescript for these patterns?
+          fallthrough?: boolean;
+        };
+      };
+    }
+);
+
+type UsageModel = "bundled" | "unbound";
+
+type Env = {
+  name?: string; // inherited
+  account_id?: string; // inherited
+  workers_dev?: boolean; // inherited
+  compatibility_date?: string; // inherited
+  compatibility_flags?: string[]; // inherited
+  zone_id?: string; // inherited
+  routes?: string[]; // inherited
+  route?: string; // inherited
+  webpack_config?: string; // inherited
+  site?: Site;
+  jsx_factory?: string; // inherited
+  jsx_fragment?: string; // inherited
+  // we should use typescript to parse cron patterns
+  triggers?: { crons: Cron[] }; // inherited
+  vars?: Vars;
+  durable_objects?: { bindings: DurableObject[] };
+  kv_namespaces?: KVNamespace[];
+  usage_model?: UsageModel; // inherited
+};
+
+export type Config = {
+  name?: string; // inherited
+  account_id?: string; // inherited
+  // @deprecated Don't use this
+  type?: Project; // top level
+  compatibility_date?: string; // inherited
+  compatibility_flags?: string[]; // inherited
+  // -- there's some mutually exclusive logic for this next block,
+  // but I didn't bother for now
+  workers_dev?: boolean; // inherited
+  zone_id?: string; // inherited
+  routes?: string[]; // inherited
+  route?: string; // inherited
+  // -- end mutually exclusive stuff
+  // @deprecated Don't use this
+  webpack_config?: string; // inherited
+  jsx_factory?: string; // inherited
+  jsx_fragment?: string; // inherited
+  vars?: Vars;
+  migrations?: DOMigration[];
+  durable_objects?: { bindings: DurableObject[] };
+  kv_namespaces?: KVNamespace[];
+  site?: Site; // inherited
+  // we should use typescript to parse cron patterns
+  triggers?: { crons: Cron[] }; // inherited
+  dev?: Dev;
+  usage_model?: UsageModel; // inherited
+  // top level
+  build?: Build;
+  env?: { [envName: string]: void | Env };
+};