two-stroke 4.4.2 → 5.0.1

package/package.json

@@ -8,27 +8,24 @@
     "type-check": "./bin/type-check.mjs"
   },
   "dependencies": {
-    "@anatine/zod-openapi": "^2.2.8",
-    "@asteasolutions/zod-to-openapi": "^7.3.0",
-    "@cloudflare/vitest-pool-workers": "^0.8.31",
-    "@cloudflare/workers-types": "^4.20250521.0",
+    "@cloudflare/vitest-pool-workers": "^0.8.32",
+    "@cloudflare/workers-types": "^4.20250522.0",
     "@sentry/cli": "^2.45.0",
     "@types/node": "^22.15.21",
     "@typescript-eslint/eslint-plugin": "^8.32.1",
     "@typescript-eslint/parser": "^8.32.1",
     "@vitest/coverage-istanbul": "^3.1.4",
     "eslint-config-prettier": "^10.1.5",
-    "eslint-config-two-stroke": "^1.1.17",
+    "eslint-config-two-stroke": "^1.1.19",
     "eslint-config-typescript": "^3.0.0",
     "jose": "^6.0.11",
     "jwk-subtle": "^1.0.7",
     "miniflare": "^4.20250508.3",
     "openapi-fetch": "^0.14.0",
     "openapi-typescript": "^7.8.0",
-    "openapi3-ts": "^4.4.0",
     "pbkdf-subtle": "^1.0.0",
     "toucan-js": "^4.1.1",
-    "zod": "^3.25.17"
+    "zod": "^3.25.20"
   },
   "peerDependencies": {
     "@sentry/cli": ">=2",
@@ -40,7 +37,7 @@
   },
   "description": "Simple Cloudflare Worker framework.",
   "engines": {
-    "node": "^20.10.0"
+    "node": "^22.16.0"
   },
   "eslintConfig": {
     "extends": [
@@ -52,7 +49,7 @@
   "name": "two-stroke",
   "packageManager": "yarn@4.6.0",
   "type": "module",
-  "version": "4.4.2",
+  "version": "5.0.1",
   "devDependencies": {
     "@types/eslint": "^9.6.1",
     "eslint": "^9.27.0",

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 { SafeParseReturnType, ZodObject, ZodSchema, z } from "zod";
+import { ZodSafeParseResult, ZodObject, z, ZodType } from "zod/v4";
 import { openAPI } from "./open-api";
 import { Env, Handler, Route } from "./types";
 
@@ -104,7 +104,6 @@ export function twoStroke<T extends Env>(title: string, release: string) {
                 response = await route.handler({
                   req,
                   env,
-                  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
                   body: body.data,
                   // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
                   claims,
@@ -310,13 +309,13 @@ export function twoStroke<T extends Env>(title: string, release: string) {
         }
         throw Error("Invalid");
       },
-    queueHandler<I extends ZodSchema>(
+    queueHandler<I extends ZodType>(
       input: I,
       handler: (c: {
         env: T;
         batch: MessageBatch<z.input<I>>;
         sentry: Toucan;
-        parsedBatch: SafeParseReturnType<z.input<I>, z.infer<I>>[];
+        parsedBatch: ZodSafeParseResult<z.output<I>>[];
       }) => Promise<void>,
     ) {
       _queue = async ({ batch, env, sentry }) => {
@@ -331,7 +330,7 @@ export function twoStroke<T extends Env>(title: string, release: string) {
         console.log("Queue batch finished");
       };
     },
-    put<I extends ZodSchema, O extends ZodSchema, A, P extends string>(
+    put<I extends ZodType, O extends ZodType, A, P extends string>(
       auth: Route<T, A>["auth"],
       path: P,
       input: I,
@@ -352,8 +351,8 @@ export function twoStroke<T extends Env>(title: string, release: string) {
     },
 
     post<
-      I extends ZodSchema | undefined,
-      O extends ZodSchema,
+      I extends ZodType | undefined,
+      O extends ZodType,
       A,
       P extends string,
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -381,7 +380,7 @@ export function twoStroke<T extends Env>(title: string, release: string) {
     },
 
     get<
-      O extends ZodSchema,
+      O extends ZodType,
       A,
       P extends string,
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -406,7 +405,7 @@ export function twoStroke<T extends Env>(title: string, release: string) {
       });
     },
     delete<
-      O extends ZodSchema,
+      O extends ZodType,
       A,
       P extends string,
       // eslint-disable-next-line @typescript-eslint/no-explicit-any

package/src/open-api.ts

@@ -1,35 +1,5 @@
-import {
-  OpenAPIRegistry,
-  OpenApiGeneratorV31,
-  extendZodWithOpenApi,
-} from "@asteasolutions/zod-to-openapi";
+import { z, ZodType } from "zod/v4";
 import { Env, Route } from "./types";
-import { ZodIssue, ZodType, z } from "zod";
-
-const ZodErrorSchema: ZodType<{ issues: ZodIssue[] }> = z.object({
-  error: z.string(),
-  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, A>(
@@ -39,80 +9,138 @@ export const openAPI =
     routes: Route<T, A>[],
   ) =>
   // eslint-disable-next-line @typescript-eslint/require-await
-  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: route.input
-                  ? {
+  async () => ({
+    body: {
+      openapi: "3.1.0",
+      info: {
+        title,
+        version: release,
+      },
+      components: {
+        securitySchemes: {
+          auth: {
+            type: "http",
+            scheme: "bearer",
+          },
+        },
+      },
+      paths: Object.fromEntries(
+        routes.map((r) => [
+          r.path,
+          {
+            [r.method.toLocaleLowerCase()]: {
+              parameters: [
+                ...Object.entries(
+                  (r.params?.shape ?? {}) as Record<string, ZodType>,
+                ).map(([k, v]) => ({
+                  name: k,
+                  in: "query",
+                  required: !v.safeParse(undefined).success,
+                  schema: z.toJSONSchema(v, { io: "input" }),
+                })),
+                ...Array.from(
+                  r.path.matchAll(/\/{(?<name>[^}]*)}/g),
+                  (match) => ({
+                    name: match.groups!.name,
+                    in: "path",
+                    required: true,
+                    schema: {
+                      type: "string",
+                    },
+                  }),
+                ),
+              ],
+              ...(r.auth === noAuth ? {} : { security: [{ auth: [] }] }),
+              ...(r.method === "POST" || r.method === "PUT"
+                ? {
+                    requestBody: {
+                      required: true,
                       content: {
-                        "application/json": {
-                          schema: route.input,
-                        },
+                        "application/json": r.input
+                          ? {
+                              schema: z.toJSONSchema(r.input, { io: "input" }),
+                            }
+                          : undefined,
                       },
-                      required: true,
-                    }
-                  : undefined,
-                query: route.params,
-                params,
-              }
-            : { query: route.params, params },
-        responses: {
-          200: {
-            description: "OK",
-            content: {
-              "application/json": {
-                schema: route.output,
+                    },
+                  }
+                : {}),
+              responses: {
+                "200": {
+                  description: "OK",
+                  content: {
+                    "application/json": {
+                      schema: z.toJSONSchema(r.output),
+                    },
+                  },
+                },
+                "400": status400,
+                "500": status500,
               },
             },
           },
-          400: {
-            description: "Invalid Request",
-            content: {
-              "application/json": {
-                schema: ZodErrorSchema,
-              },
-            },
+        ]),
+      ),
+    },
+  });
+
+const status500 = {
+  description: "Invalid Request",
+  content: {
+    "application/json": {
+      schema: {
+        type: "object",
+        properties: {
+          error: {
+            type: "string",
           },
-          500: {
-            description: "Invalid Request",
-            content: {
-              "application/json": {
-                schema: z.object({
-                  error: z.string(),
-                }),
+        },
+        required: ["error"],
+      },
+    },
+  },
+};
+const status400 = {
+  description: "Invalid Request",
+  content: {
+    "application/json": {
+      schema: {
+        type: "object",
+        properties: {
+          error: {
+            type: "string",
+          },
+          issues: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                code: {
+                  type: "string",
+                  enum: ["invalid_literal"],
+                },
+                expected: {
+                  type: "string",
+                },
+                received: {
+                  type: "string",
+                },
+                path: {
+                  type: "array",
+                  items: {
+                    type: "string",
+                  },
+                },
+                message: {
+                  type: "string",
+                },
               },
+              required: ["code", "expected", "received", "path", "message"],
             },
           },
         },
-      });
-    });
-    const generator = new OpenApiGeneratorV31(openAPIRegistry.definitions);
-    return {
-      body: generator.generateDocument({
-        openapi: "3.1.0",
-        info: {
-          title,
-          version: release,
-        },
-      }),
-    };
-  };
+        required: ["error", "issues"],
+      },
+    },
+  },
+};

package/src/types.ts

@@ -1,5 +1,5 @@
 import { Toucan } from "toucan-js";
-import { ZodObject, ZodSchema, z } from "zod";
+import { ZodType, ZodObject, z } from "zod/v4";
 export type Env = {
   [k: string]:
     | string
@@ -18,7 +18,7 @@ export type Route<T extends Env, A> =
       method: "GET" | "DELETE";
       path: string;
       matcher: RegExp;
-      output: ZodSchema;
+      output: ZodType;
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       handler: Handler<T, undefined, any, A, string>;
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -29,8 +29,8 @@ export type Route<T extends Env, A> =
       method: "POST" | "PUT";
       path: string;
       matcher: RegExp;
-      input: ZodSchema | undefined;
-      output: ZodSchema;
+      input: ZodType | undefined;
+      output: ZodType;
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       handler: Handler<T, any, any, A, string>;
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -44,14 +44,14 @@ export type ExtractParameterNames<S extends string> =
 
 export type Handler<
   T extends Env,
-  I extends ZodSchema | undefined,
-  O extends ZodSchema,
+  I extends ZodType | undefined,
+  O extends ZodType,
   A,
   P extends string,
 > = (c: {
   req: Request;
   env: T;
-  body: I extends ZodSchema ? z.infer<I> : undefined;
+  body: I extends ZodType ? z.infer<I> : undefined;
   params: ExtractParameterNames<P>;
   searchParams: URLSearchParams;
   claims: A;