two-stroke 1.0.0

package/README.md

@@ -0,0 +1,3 @@
+# two-stroke
+
+Simple Cloudflare Worker framework.

package/bin/deploy.mjs

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+"use strict";
+import { cmd } from "../src/cmd.mjs";
+import { basename } from "path";
+
+const env = process.argv[2];
+const release = process.argv[3];
+
+fs.writeFileSync("src/release.ts", `export default "${release}";`);
+
+await cmd(`wrangler secret:bulk /dev/stdin --env ${env}`);
+await cmd(
+  `sentry cli releases --org change-engine --project ${basename(process.cwd())} new ${release} --finalize`,
+);
+
+await cmd(
+  `sentry cli releases --org change-engine --project ${basename(process.cwd())} set-commits ${release}`,
+);
+
+await cmd(`wrangler deploy --env ${env} --outdir dist`);
+
+await cmd(
+  `sentry-cli sourcemaps --org change-engine --project odometer upload --release="${release}" dist`,
+);

package/bin/dev.mjs

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+"use strict";
+import { cmd } from "../src/cmd.mjs";
+
+await cmd("wrangler dev");

package/bin/format.mjs

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+"use strict";
+import { cmd } from "../src/cmd.mjs";
+
+await cmd("prettier --write . !tsconfig.json");

package/bin/lint.mjs

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+"use strict";
+import { cmd } from "../src/cmd.mjs";
+
+await cmd("eslint --max-warnings=0 src");
+await cmd("prettier --check . !tsconfig.json");

package/bin/test.mjs

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+"use strict";
+import fs from "fs";
+import { cmd } from "../src/cmd.mjs";
+import consumers from "stream/consumers";
+import openapiTS from "openapi-typescript";
+
+if (fs.existsSync("wrangler.toml")) {
+  await cmd("wrangler deploy --dry-run --outdir=dist");
+  const app = await import(`${process.cwd()}/dist/index.js`);
+  const request = await app.default.fetch(
+    { url: "http://example.com/doc/", method: "GET" },
+    { SENTRY_DSN: null, SENTRY_ENVIRONMENT: null },
+    null,
+  );
+  const types = await openapiTS(await consumers.json(request.body));
+  fs.writeFileSync("test/api.d.ts", types);
+}
+await cmd(
+  "vitest --globals --no-file-parallelism --run --coverage",
+  process.argv.slice(2),
+);

package/bin/type-check.mjs

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+"use strict";
+import { cmd } from "../src/cmd.mjs";
+
+cmd("tsc --noEmit");

package/package.json

@@ -0,0 +1,61 @@
+{
+  "bin": {
+    "dev": "./bin/dev.mjs",
+    "format": "./bin/format.mjs",
+    "lint": "./bin/lint.mjs",
+    "test": "./bin/test.mjs",
+    "type-check": "./bin/type-check.mjs"
+  },
+  "dependencies": {
+    "@anatine/zod-openapi": "^2.2.3",
+    "@asteasolutions/zod-to-openapi": "^6.3.1",
+    "@cloudflare/workers-types": "^4.20240208.0",
+    "@sentry/cli": "^2.28.6",
+    "@typescript-eslint/eslint-plugin": "^7.0.1",
+    "@typescript-eslint/parser": "^7.0.1",
+    "@vitest/coverage-v8": "^1.2.2",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-config-two-stroke": "^1.0.0",
+    "eslint-config-typescript": "^3.0.0",
+    "jwk-subtle": "^1.0.6",
+    "miniflare": "^3.20240129.1",
+    "openapi-fetch": "^0.8.2",
+    "openapi-typescript": "^6.7.4",
+    "openapi3-ts": "^4.2.1",
+    "pbkdf-subtle": "^1.0.0",
+    "toml": "^3.0.0",
+    "toucan-js": "^3.3.1",
+    "zod": "^3.22.4"
+  },
+  "peerDependencies": {
+    "@sentry/cli": ">=2",
+    "eslint": ">=8",
+    "prettier": ">=3",
+    "typescript": ">=5",
+    "vitest": ">=1",
+    "wrangler": ">=3"
+  },
+  "description": "Simple Cloudflare Worker framework.",
+  "engines": {
+    "node": "^20.10.0"
+  },
+  "eslintConfig": {
+    "extends": [
+      "two-stroke"
+    ]
+  },
+  "license": "MIT",
+  "main": "src/index.ts",
+  "name": "two-stroke",
+  "packageManager": "yarn@4.1.0",
+  "type": "module",
+  "version": "1.0.0",
+  "devDependencies": {
+    "@types/eslint": "^8.56.2",
+    "@types/node": "^20.11.17",
+    "eslint": "^8.56.0",
+    "prettier": "^3.2.5",
+    "typescript": "^5.3.3",
+    "vitest": "^1.2.2"
+  }
+}

package/src/cmd.mjs

@@ -0,0 +1,10 @@
+import { spawn } from "child_process";
+
+export function cmd(cmd, args = []) {
+  const p = spawn(cmd.split(" ")[0], [...cmd.split(" ").slice(1), ...args], {
+    stdio: "inherit",
+  });
+  return new Promise((resolve) => {
+    p.on("exit", resolve);
+  });
+}

package/src/index.ts

@@ -0,0 +1,344 @@
+import { Toucan } from "toucan-js";
+import { ZodObject, ZodSchema, z } from "zod";
+import { verify as pbkdfVerify } from "pbkdf-subtle";
+import { verify as jwkVerify } from "jwk-subtle";
+import { Env, Handler, Route } from "./types";
+import { openAPI } from "./openAPI";
+
+const noAuth = async () => null;
+
+const escapeRegex = (str: string) =>
+  str.replace(/([.*+?^=!:$()|[\]\\])/g, "\\$&");
+
+export function twoStroke<T extends Env>(title: string, release: string) {
+  let _queue: (c: {
+    batch: MessageBatch;
+    env: T;
+    sentry: Toucan;
+  }) => Promise<void>;
+  const routes: Route<T>[] = [];
+  routes.push({
+    auth: noAuth,
+    method: "GET",
+    path: "/doc/",
+    matcher: /^\/doc\/$/,
+    output: z.object({}),
+    handler: openAPI(title, release, noAuth, routes),
+  });
+  const crons: {
+    [cron: string]: (c: { env: T; sentry: Toucan }) => Promise<void>;
+  } = {};
+  let _email: (c: {
+    message: ForwardableEmailMessage;
+    env: T;
+    sentry: Toucan;
+  }) => Promise<void>;
+  return {
+    async fetch(
+      req: Request,
+      env: T & {
+        readonly SENTRY_DSN: string;
+        readonly SENTRY_ENVIRONMENT: string;
+      },
+      context: ExecutionContext,
+    ): Promise<Response> {
+      const sentry = new Toucan({
+        dsn: env.SENTRY_DSN,
+        context,
+        request: req,
+        requestDataOptions: {
+          allowedHeaders: ["user-agent"],
+        },
+        environment: env.SENTRY_ENVIRONMENT,
+        release,
+      });
+      try {
+        const { pathname } = new URL(req.url);
+        let response;
+        for (const route of routes) {
+          if (req.method === route.method && route.matcher.test(pathname)) {
+            const params = pathname.match(route.matcher)?.groups ?? {};
+            let claims;
+            try {
+              claims = await route.auth({ req, env });
+            } catch (err) {
+              console.warn(err);
+              return new Response("", {
+                status: 401,
+                statusText: "Invalid Authorization",
+                headers: {
+                  "WWW-Authenticate": "Bearer",
+                },
+              });
+            }
+            if (route.method === "POST" || route.method === "PUT") {
+              const rawBody =
+                req.headers.get("Content-Type") ===
+                "application/x-www-form-urlencoded"
+                  ? Object.fromEntries(new URLSearchParams(await req.text()))
+                  : await req.json();
+              const body = route.input.safeParse(rawBody);
+              if (body.success)
+                response = await route.handler({
+                  req,
+                  env,
+                  body: body.data,
+                  claims,
+                  params,
+                  searchParams: new URL(req.url).searchParams,
+                  sentry,
+                });
+              else {
+                console.error(body.error, rawBody);
+                return new Response(JSON.stringify(body.error), {
+                  status: 400,
+                });
+              }
+            } else {
+              response = await route.handler({
+                req,
+                env,
+                claims,
+                body: undefined,
+                params,
+                searchParams: new URL(req.url).searchParams,
+                sentry,
+              });
+            }
+            const output = route.output.safeParse(response.body);
+            if (!output.success) {
+              console.error(output.error, response.body);
+            }
+            response.headers = response.headers ?? {};
+            response.headers["Content-Type"] =
+              response.headers["Content-Type"] ?? "application/json";
+            return new Response(
+              response.headers["Content-Type"] == "application/json"
+                ? JSON.stringify(response.body)
+                : response.body,
+              response,
+            );
+          }
+        }
+        return new Response("", { status: 404 });
+      } catch (err) {
+        console.warn(err);
+        sentry.captureException(err);
+        return new Response("", {
+          status: 500,
+          statusText: "Internal Server Error",
+        });
+      }
+    },
+    async queue(
+      batch: MessageBatch,
+      env: T & {
+        readonly SENTRY_DSN: string;
+        readonly SENTRY_ENVIRONMENT: string;
+      },
+      context: ExecutionContext,
+    ) {
+      const sentry = new Toucan({
+        dsn: env.SENTRY_DSN,
+        context,
+        environment: env.SENTRY_ENVIRONMENT,
+        release,
+      });
+      return await _queue({ batch, env, sentry });
+    },
+    async scheduled(
+      event: ScheduledEvent,
+      env: T & {
+        readonly SENTRY_DSN: string;
+        readonly SENTRY_ENVIRONMENT: string;
+      },
+      context: ExecutionContext,
+    ) {
+      const sentry = new Toucan({
+        dsn: env.SENTRY_DSN,
+        context,
+        environment: env.SENTRY_ENVIRONMENT,
+        release,
+      });
+      const handler = crons[event.cron];
+      if (!handler) {
+        throw new Error("CRON Handler not found");
+      }
+      await handler({ env, sentry });
+    },
+    async email(
+      message: ForwardableEmailMessage,
+      env: T & {
+        readonly SENTRY_DSN: string;
+        readonly SENTRY_ENVIRONMENT: string;
+      },
+      context: ExecutionContext,
+    ) {
+      const sentry = new Toucan({
+        dsn: env.SENTRY_DSN,
+        context,
+        environment: env.SENTRY_ENVIRONMENT,
+        release,
+      });
+      await _email({ message, env, sentry });
+    },
+    emailHandler(
+      handler: (c: {
+        env: T;
+        message: ForwardableEmailMessage;
+        sentry: Toucan;
+      }) => Promise<void>,
+    ) {
+      _email = handler;
+    },
+    schedule(
+      cron: string,
+      handler: (c: { env: T; sentry: Toucan }) => Promise<void>,
+    ) {
+      crons[cron] = handler;
+    },
+    noAuth,
+    pbkdf:
+      (k: keyof T) =>
+      async ({ req, env }: { req: Request; env: T }) => {
+        const [scheme, token] = (req.headers.get("Authorization") ?? " ").split(
+          " ",
+        );
+        if (
+          (scheme === "token" || scheme === "Bearer") &&
+          (await pbkdfVerify(env[k] as string, token ?? ""))
+        )
+          return;
+        throw Error("Invalid");
+      },
+    jwt:
+      <J>(k: keyof T, ak: keyof T) =>
+      async ({ req, env }: { req: Request; env: T }) => {
+        const [scheme, token] = (req.headers.get("Authorization") ?? " ").split(
+          " ",
+        );
+        if (scheme == "Bearer") {
+          const claims = await jwkVerify<J>(
+            token ?? "",
+            env[k] as string,
+            env[ak] as string,
+          );
+          if (!claims) {
+            throw Error("Invalid");
+          }
+          return claims;
+        }
+        throw Error("Invalid");
+      },
+    queueHandler<I extends ZodSchema>(
+      input: I,
+      handler: (c: {
+        env: T;
+        batch: MessageBatch<z.infer<I>>;
+        sentry: Toucan;
+      }) => Promise<void>,
+    ) {
+      _queue = async ({ batch, env, sentry }) => {
+        batch.messages.map((message): void => {
+          const body = input.safeParse(message.body);
+          if (!body.success) {
+            console.error(body.error, message);
+          }
+        });
+        await handler({ batch, env, sentry });
+        console.log("Queue batch finished");
+      };
+    },
+    put<I extends ZodSchema, O extends ZodSchema, A, P extends string>(
+      auth: Route<T>["auth"],
+      path: P,
+      input: I,
+      output: O,
+      handler: Handler<T, I, O, A, P>,
+    ) {
+      routes.push({
+        auth,
+        method: "PUT",
+        path,
+        matcher: new RegExp(
+          `^${escapeRegex(path).replaceAll(/\/{([^}]*)}/g, "/(?<$1>[^\\/]*)")}$`,
+        ),
+        input,
+        output,
+        handler,
+      });
+    },
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    post<
+      I extends ZodSchema,
+      O extends ZodSchema,
+      A,
+      P extends string,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      PP extends ZodObject<any> | undefined,
+    >(
+      auth: Route<T>["auth"],
+      path: P,
+      input: I,
+      output: O,
+      handler: Handler<T, I, O, A, P>,
+      params?: PP,
+    ) {
+      routes.push({
+        auth,
+        method: "POST",
+        path,
+        matcher: new RegExp(
+          `^${escapeRegex(path).replaceAll(/\/{([^}]*)}/g, "/(?<$1>[^\\/]*)")}$`,
+        ),
+        input,
+        output,
+        handler,
+        params,
+      });
+    },
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    get<
+      O extends ZodSchema,
+      A,
+      P extends string,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      PP extends ZodObject<any> | undefined,
+    >(
+      auth: Route<T>["auth"],
+      path: P,
+      output: O,
+      handler: Handler<T, undefined, O, A, P>,
+      params?: PP,
+    ) {
+      routes.push({
+        auth,
+        method: "GET",
+        path,
+        matcher: new RegExp(
+          `^${escapeRegex(path).replaceAll(/\/{([^}]*)}/g, "/(?<$1>[^\\/]*)")}$`,
+        ),
+        output,
+        handler,
+        params,
+      });
+    },
+    delete<O extends ZodSchema, A, P extends string>(
+      auth: Route<T>["auth"],
+      path: P,
+      output: O,
+      handler: Handler<T, undefined, O, A, P>,
+    ) {
+      routes.push({
+        auth,
+        method: "DELETE",
+        path,
+        matcher: new RegExp(
+          `^${escapeRegex(path).replaceAll(/\/{([^}]*)}/g, "/(?<$1>[^\\/]*)")}$`,
+        ),
+        output,
+        handler,
+      });
+    },
+  };
+}

package/src/openAPI.ts

@@ -0,0 +1,104 @@
+import {
+  OpenAPIRegistry,
+  OpenApiGeneratorV31,
+  extendZodWithOpenApi,
+} from "@asteasolutions/zod-to-openapi";
+import { Env, Route } from "./types";
+import { ZodIssue, ZodType, z } from "zod";
+
+const ZodErrorSchema: ZodType<{ issues: ZodIssue[] }> = z.object({
+  issues: z.array(
+    z.object({
+      code: z.literal("invalid_literal"),
+      expected: z.string(),
+      received: z.string(),
+      path: z.array(z.string()),
+      message: z.string(),
+    }),
+  ),
+});
+
+type Method =
+  | "get"
+  | "post"
+  | "put"
+  | "delete"
+  | "patch"
+  | "head"
+  | "options"
+  | "trace";
+
+extendZodWithOpenApi(z);
+
+export const openAPI =
+  <T extends Env>(
+    title: string,
+    release: string,
+    noAuth: () => void,
+    routes: Route<T>[],
+  ) =>
+  async () => {
+    const openAPIRegistry = new OpenAPIRegistry();
+    openAPIRegistry.registerComponent("securitySchemes", "auth", {
+      type: "http",
+      scheme: "bearer",
+    });
+    routes.map((route): void => {
+      const params = z.object(
+        Object.fromEntries(
+          Array.from(route.path.matchAll(/\/{(?<name>[^}]*)}/g), (match) => [
+            match.groups!.name,
+            z.string(),
+          ]),
+        ),
+      );
+      openAPIRegistry.registerPath({
+        method: route.method.toLowerCase() as Method,
+        path: route.path.toString(),
+        ...(route.auth === noAuth ? {} : { security: [{ auth: [] }] }),
+        request:
+          route.method === "POST" || route.method === "PUT"
+            ? {
+                body: {
+                  content: {
+                    "application/json": {
+                      schema: route.input,
+                    },
+                  },
+                  required: true,
+                },
+                query: route.params,
+                params,
+              }
+            : { query: route.params, params },
+        responses: {
+          200: {
+            description: "OK",
+            content: {
+              "application/json": {
+                schema: route.output,
+              },
+            },
+          },
+          400: {
+            description: "Invalid Request",
+            content: {
+              "application/json": {
+                schema: ZodErrorSchema,
+              },
+            },
+          },
+        },
+      });
+    });
+    const generator = new OpenApiGeneratorV31(openAPIRegistry.definitions);
+    return {
+      body: generator.generateDocument({
+        openapi: "3.1",
+        info: {
+          title,
+          version: release,
+        },
+      }),
+    };
+  };

package/src/test.ts

@@ -0,0 +1,145 @@
+import { Miniflare, createFetchMock } from "miniflare";
+import toml from "toml";
+import fs from "fs";
+import { Env } from "./types";
+import consumers from "stream/consumers";
+import { URLSearchParams } from "url";
+import createClient from "openapi-fetch";
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+export const setupTests = async <Paths extends {}>(bindings: Env) => {
+  const fetchMock = createFetchMock();
+  fetchMock.disableNetConnect();
+
+  const config = toml.parse(fs.readFileSync("wrangler.toml", "utf8"));
+
+  const miniflare = new Miniflare({
+    modules: true,
+    scriptPath: "dist/index.js",
+    bindings: {
+      TOKEN_HASH:
+        "djAxlhzT1IU9QIP3UKdipECQPAGGoPQK86/GnTBcbHLtPC3ni6JkTQ/iIeF0KG0y1CZ+J+9W",
+      ...bindings,
+    },
+    queueConsumers: (config.queues?.consumers ?? []).map(
+      ({ queue }: { queue: string }) => queue,
+    ),
+    queueProducers: Object.fromEntries(
+      (config.queues?.producers ?? []).map(
+        ({ binding, queue }: { queue: string; binding: string }) => [
+          binding,
+          queue,
+        ],
+      ),
+    ),
+    r2Buckets: (config.r2_buckets ?? []).map(
+      ({ binding }: { binding: string }) => binding,
+    ),
+    kvNamespaces: (config.kv_namespaces ?? []).map(
+      ({ binding }: { binding: string }) => binding,
+    ),
+    d1Databases: (config.d1_databases ?? []).map(
+      ({ binding }: { binding: string }) => binding,
+    ),
+    fetchMock,
+  });
+
+  const url = await miniflare.ready;
+
+  const client = createClient<Paths>({ baseUrl: url.toString() });
+
+  return {
+    url,
+    miniflare,
+    fetchMock,
+    client,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    testFetch(path: string, config: any) {
+      const contentType = config.body
+        ? config.headers["Content-Type"] ?? "application/json"
+        : null;
+      return fetch(`${url}${path}`, {
+        ...config,
+        headers: {
+          ...(config.body ? { "Content-Type": contentType } : {}),
+          ...(config.headers ?? {}),
+        },
+        body:
+          contentType === "application/json"
+            ? JSON.stringify(config.body)
+            : contentType === "application/x-www-form-urlencoded"
+              ? new URLSearchParams(config.body)
+              : null,
+      });
+    },
+    async waitForQueue(trigger: () => Promise<void>) {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const log: any = [];
+      const orig = console.log;
+      console.log = function (message) {
+        orig(message);
+        log.push(message);
+      };
+      await trigger();
+      await waitUntil(() => expect(log).contains("Queue batch finished"));
+      console.log = orig;
+    },
+  };
+};
+
+async function waitUntil(condition: () => void, time = 100) {
+  try {
+    condition();
+    return;
+  } catch {
+    await new Promise((resolve) => setTimeout(resolve, time));
+    await waitUntil(condition, time);
+  }
+}
+
+export function recordRequest(
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  cb: (data: any) => void,
+  statusCode: number,
+  data: string | object | Buffer | undefined,
+) {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  return ({ body }: any) => {
+    consumers.json(body).then(cb);
+    return { statusCode, data };
+  };
+}
+
+export function recordFormRequest(
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  cb: (data: any) => void,
+  statusCode: number,
+  data: string | object | Buffer | undefined,
+) {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  return ({ body }: any) => {
+    consumers
+      .text(body)
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      .then((data: any) =>
+        cb(Object.fromEntries(new URLSearchParams(data).entries())),
+      );
+    return { statusCode, data };
+  };
+}
+
+export function recordFirehoseRequest(
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  cb: (data: any) => void,
+  statusCode: number,
+  data: string | object | Buffer | undefined,
+) {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  return ({ body }: any) => {
+    consumers
+      .json(body)
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      .then((data: any) => cb(JSON.parse(atob(data["Record"]["Data"]))));
+    return { statusCode, data };
+  };
+}

package/src/types.ts

@@ -0,0 +1,54 @@
+import { Toucan } from "toucan-js";
+import { ZodObject, ZodSchema, z } from "zod";
+export type Env = {
+  [k: string]: string | Queue | KVNamespace | R2Bucket | D1Database;
+};
+export type Route<T extends Env> =
+  | {
+      auth: (c: { req: Request; env: T }) => unknown;
+      method: "GET" | "DELETE";
+      path: string;
+      matcher: RegExp;
+      output: ZodSchema;
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      handler: Handler<T, undefined, any, any, string>;
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      params?: ZodObject<any>;
+    }
+  | {
+      auth: (c: { req: Request; env: T }) => unknown;
+      method: "POST" | "PUT";
+      path: string;
+      matcher: RegExp;
+      input: ZodSchema;
+      output: ZodSchema;
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      handler: Handler<T, any, any, any, string>;
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      params?: ZodObject<any>;
+    };
+
+export type ExtractParameterNames<S extends string> =
+  S extends `${string}{${infer Name}}${infer Rest}`
+    ? Record<Name, string> & ExtractParameterNames<Rest>
+    : Record<string, string>;
+
+export type Handler<
+  T extends Env,
+  I extends ZodSchema | undefined,
+  O extends ZodSchema,
+  A,
+  P extends string,
+> = (c: {
+  req: Request;
+  env: T;
+  body: I extends ZodSchema ? z.infer<I> : undefined;
+  params: ExtractParameterNames<P>;
+  searchParams: URLSearchParams;
+  claims: A;
+  sentry: Toucan;
+}) => Promise<{
+  body: z.infer<O>;
+  status?: number;
+  headers?: Record<string, string>;
+}>;

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "esModuleInterop": true,
+    "isolatedModules": true,
+    "lib": [
+      "ESNext"
+    ],
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "noUncheckedIndexedAccess": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "target": "ESNext",
+    "types": [
+      "@cloudflare/workers-types",
+      "vitest/globals"
+    ]
+  }
+}