two-stroke 2.0.0 → 4.0.0

package/bin/test.mjs

@@ -13,6 +13,8 @@ if (fs.existsSync("wrangler.toml")) {
   const miniflare = new Miniflare({
     modules: true,
     scriptPath: "dist/index.js",
+    compatibilityDate: "2024-09-23",
+    compatibilityFlags: ["nodejs_compat"],
   });
   const request = await fetch(
     // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
@@ -20,25 +22,27 @@ if (fs.existsSync("wrangler.toml")) {
     { SENTRY_DSN: null, SENTRY_ENVIRONMENT: null },
     null,
   );
-  const types = await openapiTS(await consumers.json(request.body));
   await miniflare.dispose();
-  const printer = ts.createPrinter({});
-  const resultFile = ts.createSourceFile(
-    "test/api.d.ts",
-    "",
-    ts.ScriptTarget.Latest,
-  );
-  const result = printer.printNode(
-    ts.EmitHint.Unspecified,
-    types[0],
-    resultFile,
-  );
-  fs.writeFileSync(
-    "test/api.d.ts",
-    await prettier.format(result, { parser: "typescript" }),
-  );
+  if (request.status === 200) {
+    const types = await openapiTS(await consumers.json(request.body));
+    const printer = ts.createPrinter({});
+    const resultFile = ts.createSourceFile(
+      "test/api.d.ts",
+      "",
+      ts.ScriptTarget.Latest,
+    );
+    const result = printer.printNode(
+      ts.EmitHint.Unspecified,
+      types[0],
+      resultFile,
+    );
+    fs.writeFileSync(
+      "test/api.d.ts",
+      await prettier.format(result, { parser: "typescript" }),
+    );
+  }
 }
-cmd("vitest --globals --no-file-parallelism --pool threads", [
+cmd("vitest", [
   ...(!process.argv.slice(2).includes("-w") &&
   !process.argv.slice(2).includes("--watch")
     ? ["--run"]

package/package.json

@@ -10,22 +10,22 @@
   "dependencies": {
     "@anatine/zod-openapi": "^2.2.6",
     "@asteasolutions/zod-to-openapi": "^7.2.0",
-    "@cloudflare/workers-types": "^4.20241011.0",
-    "@sentry/cli": "^2.37.0",
-    "@typescript-eslint/eslint-plugin": "^8.8.1",
-    "@typescript-eslint/parser": "^8.8.1",
-    "@vitest/coverage-v8": "^2.1.3",
+    "@cloudflare/vitest-pool-workers": "^0.5.22",
+    "@cloudflare/workers-types": "^4.20241022.0",
+    "@sentry/cli": "^2.38.0",
+    "@typescript-eslint/eslint-plugin": "^8.11.0",
+    "@typescript-eslint/parser": "^8.11.0",
+    "@vitest/coverage-istanbul": "^2.1.3",
     "eslint-config-prettier": "^9.1.0",
     "eslint-config-two-stroke": "^1.1.5",
     "eslint-config-typescript": "^3.0.0",
-    "jose": "^5.9.4",
+    "jose": "^5.9.6",
     "jwk-subtle": "^1.0.7",
-    "miniflare": "^3.20241004.0",
-    "openapi-fetch": "^0.12.2",
-    "openapi-typescript": "^7.4.1",
+    "miniflare": "^3.20241022.0",
+    "openapi-fetch": "^0.13.0",
+    "openapi-typescript": "^7.4.2",
     "openapi3-ts": "^4.4.0",
     "pbkdf-subtle": "^1.0.0",
-    "toml": "^3.0.0",
     "toucan-js": "^4.0.0",
     "zod": "^3.23.8"
   },
@@ -51,11 +51,11 @@
   "name": "two-stroke",
   "packageManager": "yarn@4.3.0",
   "type": "module",
-  "version": "2.0.0",
+  "version": "4.0.0",
   "devDependencies": {
     "@types/eslint": "^9.6.1",
-    "@types/node": "^22.7.5",
-    "eslint": "^9.12.0",
+    "@types/node": "^22.8.1",
+    "eslint": "^9.13.0",
     "prettier": "^3.3.3",
     "typescript": "^5.6.3",
     "vitest": "^2.1.3"

package/src/index.ts

@@ -1,7 +1,7 @@
 import { verify as jwkVerify } from "jwk-subtle";
 import { verify as pbkdfVerify } from "pbkdf-subtle";
 import { Toucan } from "toucan-js";
-import { SafeParseError, ZodObject, ZodSchema, z } from "zod";
+import { SafeParseReturnType, ZodObject, ZodSchema, z } from "zod";
 import { openAPI } from "./open-api";
 import { Env, Handler, Route } from "./types";
 
@@ -288,56 +288,24 @@ export function twoStroke<T extends Env>(title: string, release: string) {
         }
         throw Error("Invalid");
       },
-    queueHandler<I extends ZodSchema, Parsed = z.infer<I>>(
+    queueHandler<I extends ZodSchema>(
       input: I,
       handler: (c: {
         env: T;
-        batch: MessageBatch<Parsed>;
-        sentry: Toucan;
-      }) => Promise<void>,
-      parseFailedHandler?: (c: {
-        env: T;
-        batch: MessageBatch & {
-          messages: (Message<unknown> & {
-            error: SafeParseError<z.input<I>>;
-          })[];
-        };
+        batch: MessageBatch<z.input<I>>;
         sentry: Toucan;
+        parsedBatch: SafeParseReturnType<z.input<I>, z.infer<I>>[];
       }) => Promise<void>,
     ) {
       _queue = async ({ batch, env, sentry }) => {
-        const { messages, failed } = batch.messages.reduce<{
-          messages: Message<Parsed>[];
-          failed: (Message<unknown> & { error: SafeParseError<z.input<I>> })[];
-        }>(
-          (acc, message) => {
-            const body: z.SafeParseReturnType<
-              z.input<I>,
-              Parsed
-            > = input.safeParse(message.body);
-            if (!body.success) {
-              console.error(body.error, message);
-              return {
-                messages: acc.messages,
-                failed: [...acc.failed, { ...message, error: body }],
-              };
-            }
-
-            return {
-              messages: [...acc.messages, { ...message, body: body.data }],
-              failed: acc.failed,
-            };
-          },
-          { messages: [], failed: [] },
-        );
-
-        await handler({ batch: { ...batch, messages }, env, sentry });
-        if (failed.length > 0)
-          await parseFailedHandler?.({
-            batch: { ...batch, messages: failed },
-            env,
-            sentry,
-          });
+        const parsedBatch = batch.messages.map((message) => {
+          const passed = input.safeParse(message.body);
+          if (!passed.success) {
+            console.error(passed.error, message);
+          }
+          return passed;
+        });
+        await handler({ batch, env, sentry, parsedBatch });
         console.log("Queue batch finished");
       };
     },

package/src/test.ts

@@ -1,113 +1,24 @@
-import fs from "fs";
 import { JWTPayload, SignJWT, exportJWK, generateKeyPair } from "jose";
-import { Miniflare, createFetchMock } from "miniflare";
-import nodefs from "node:fs/promises";
-import path from "node:path";
+import { fetchMock, SELF, env } from "cloudflare:test";
 import createClient from "openapi-fetch";
 import consumers from "stream/consumers";
-import toml from "toml";
-import { URLSearchParams } from "url";
-import { Env } from "./types";
 
-// eslint-disable-next-line @typescript-eslint/no-empty-object-type
-export const setupTests = async <Paths extends {}>(bindings: Env) => {
-  const fetchMock = createFetchMock();
-  fetchMock.disableNetConnect();
-
-  const config = toml.parse(fs.readFileSync("wrangler.toml", "utf8")) as {
-    compatibility_date: string;
-    compatibility_flags: string[];
-    queues?: {
-      consumers?: { queue: string }[];
-      producers?: { queue: string; binding: string }[];
-    };
-    r2_buckets?: { binding: string }[];
-    kv_namespaces?: { binding: string }[];
-    d1_databases?: { binding: string }[];
-    services?: { binding: string; service: string }[];
-    durable_objects?: { bindings?: { name: string; class_name: string }[] };
-  };
-
-  const miniflare = new Miniflare({
-    modules: true,
-    scriptPath: "dist/index.js",
-    compatibilityDate: config.compatibility_date,
-    compatibilityFlags: config.compatibility_flags,
-    bindings: {
-      TOKEN_HASH:
-        "djAxlhzT1IU9QIP3UKdipECQPAGGoPQK86/GnTBcbHLtPC3ni6JkTQ/iIeF0KG0y1CZ+J+9W",
-      ...bindings,
-    },
-    queueConsumers: (config.queues?.consumers ?? []).map(({ queue }) => queue),
-    queueProducers: Object.fromEntries(
-      (config.queues?.producers ?? []).map(({ binding, queue: queueName }) => [
-        binding,
-        { queueName },
-      ]),
-    ),
-    r2Buckets: (config.r2_buckets ?? []).map(({ binding }) => binding),
-    kvNamespaces: (config.kv_namespaces ?? []).map(({ binding }) => binding),
-    d1Databases: (config.d1_databases ?? []).map(({ binding }) => binding),
-    serviceBindings: Object.fromEntries(
-      (config.services ?? []).map(({ binding, service }) => [binding, service]),
-    ),
-    fetchMock,
-    durableObjects: Object.fromEntries(
-      (config.durable_objects?.bindings ?? []).map(({ name, class_name }) => [
-        name,
-        class_name,
-      ]),
-    ),
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type, @typescript-eslint/require-await
+export const setupTests = async <Paths extends {}>() => {
+  beforeAll(() => {
+    fetchMock.activate();
+    fetchMock.disableNetConnect();
   });
 
-  const url = await miniflare.ready;
-
-  // Hack until miniflare supports auto running D1 migrations.
-  // Note: Each migration file can contain only a single statement.
-  await Promise.all(
-    (config.d1_databases ?? []).map(
-      async ({ binding }: { binding: string }) => {
-        const d1 = await miniflare.getD1Database(binding);
-
-        const migrationsDir = "./migrations";
-        let fileNames: string[] = [];
-        try {
-          fileNames = await nodefs.readdir(migrationsDir);
-        } catch (error) {
-          console.log("Error loading migrations", error);
-        }
+  const url = new URL("https://example.com/");
 
-        if (fileNames.length === 0)
-          console.log("No migrations found in ./migrations");
-
-        for (const migrationName of fileNames.sort((a, b) => {
-          const migrationNumberA = parseInt(a.split("_")[0]!);
-          const migrationNumberB = parseInt(b.split("_")[0]!);
-          if (migrationNumberA < migrationNumberB) {
-            return -1;
-          }
-          if (migrationNumberA > migrationNumberB) {
-            return 1;
-          }
-
-          // numbers must be equal
-          return 0;
-        })) {
-          const migrationPath = path.join(migrationsDir, migrationName);
-          let migration = await nodefs.readFile(migrationPath, "utf8");
-          // Remove migration comment
-          migration = migration.split("\n").slice(1).join(" ");
-          await d1.exec(migration);
-        }
-      },
-    ),
-  );
-
-  const client = createClient<Paths>({ baseUrl: url.toString() });
+  const client = createClient<Paths>({
+    baseUrl: url.toString(),
+    fetch: (...r) => SELF.fetch(...r),
+  });
 
   return {
     url,
-    miniflare,
     fetchMock,
     client,
     async waitForQueue(trigger: () => Promise<void>) {
@@ -122,48 +33,57 @@ export const setupTests = async <Paths extends {}>(bindings: Env) => {
       await waitUntil(() => expect(log).contains("Queue batch finished"));
       console.log = orig;
     },
-    async fakeJWK(issuer: string, audience: string, claims: JWTPayload) {
+    async fakeJWK(
+      issuer: keyof typeof env,
+      audience: keyof typeof env,
+      claims: JWTPayload,
+    ) {
       const { publicKey, privateKey } = await generateKeyPair("RS256");
       const jwk = await exportJWK(publicKey);
       jwk.kid = "test";
       jwk.alg = "RS256";
-      fetchMock
-        .get(bindings[issuer] as string)
-        .intercept({ method: "GET", path: "/.well-known/openid-configuration" })
-        .reply(
-          200,
-          {
-            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-            jwks_uri: `${bindings[issuer]}/.well-known/jwks`,
-          },
-          {
-            headers: {
-              "Content-Type": "application/json",
+      beforeAll(() => {
+        fetchMock
+          .get(env[issuer] as string)
+          .intercept({
+            method: "GET",
+            path: "/.well-known/openid-configuration",
+          })
+          .reply(
+            200,
+            {
+              // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+              jwks_uri: `${env[issuer]}/.well-known/jwks`,
+            },
+            {
+              headers: {
+                "Content-Type": "application/json",
+              },
+            },
+          )
+          .persist();
+        fetchMock
+          .get(env[issuer] as string)
+          .intercept({ method: "GET", path: "/.well-known/jwks" })
+          .reply(
+            200,
+            {
+              keys: [jwk],
             },
-          },
-        )
-        .persist();
-      fetchMock
-        .get(bindings[issuer] as string)
-        .intercept({ method: "GET", path: "/.well-known/jwks" })
-        .reply(
-          200,
-          {
-            keys: [jwk],
-          },
-          {
-            headers: {
-              "Content-Type": "application/json",
+            {
+              headers: {
+                "Content-Type": "application/json",
+              },
             },
-          },
-        )
-        .persist();
+          )
+          .persist();
+      });
       return await new SignJWT(claims)
         .setProtectedHeader({ typ: "JWT", alg: "RS256", kid: jwk.kid })
         .setIssuedAt()
         .setNotBefore("5 minutes ago")
-        .setIssuer(bindings[issuer] as string)
-        .setAudience([bindings[audience] as string])
+        .setIssuer(env[issuer] as string)
+        .setAudience([env[audience] as string])
         .setExpirationTime("1h")
         .sign(privateKey);
     },

package/src/types.ts

@@ -9,7 +9,8 @@ export type Env = {
     | D1Database
     | Fetcher
     | Hyperdrive
-    | DurableObjectNamespace;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    | DurableObjectNamespace<any>;
 };
 export type Route<T extends Env, A> =
   | {

package/tsconfig.json

@@ -11,6 +11,11 @@
     "skipLibCheck": true,
     "strict": true,
     "target": "ESNext",
-    "types": ["@cloudflare/workers-types", "vitest/globals"]
-  }
+    "types": [
+      "@cloudflare/workers-types",
+      "vitest/globals",
+      "@cloudflare/vitest-pool-workers"
+    ]
+  },
+  "exclude": ["../../dist"]
 }