two-stroke 4.3.0 → 4.3.2

package/README.md

@@ -1,3 +1,148 @@
 # two-stroke
 
-Simple Cloudflare Worker framework.
+A minimalist framework for Cloudflare Workers with built-in routing, authentication, and validation.
+
+## Overview
+
+Two-Stroke is a lightweight framework for building APIs with Cloudflare Workers. It provides a structured approach to defining routes, handling authentication, validating requests and responses with Zod, and managing errors with Sentry.
+
+## Features
+
+- **Type-safe routing** with path parameter extraction
+- **Schema validation** for request and response bodies using Zod
+- **Built-in authentication** methods (JWT, PBKDF)
+- **Error handling** with Sentry integration
+- **CORS support** out of the box
+- **Queue handling** for background processing
+- **Cron job support** for scheduled tasks
+- **Email handling** capabilities
+- **OpenAPI documentation** generation
+
+## Installation
+
+```bash
+npm install two-stroke
+```
+
+## Quick Start
+
+```typescript
+import { twoStroke } from "two-stroke";
+import { z } from "zod";
+
+// Define your environment type
+type MyEnv = {
+  MY_SECRET: string;
+  MY_KV: KVNamespace;
+};
+
+// Create a Two-Stroke app
+const app = twoStroke<MyEnv>("My API", "1.0.0");
+
+// Define routes
+app.get(
+  app.noAuth,
+  "/hello",
+  z.object({ message: z.string() }),
+  async ({ env }) => {
+    return {
+      body: { message: "Hello, World!" },
+    };
+  }
+);
+
+// Define a route with path parameters
+app.get(
+  app.noAuth,
+  "/users/{userId}",
+  z.object({ user: z.object({ id: z.string(), name: z.string() }) }),
+  async ({ params }) => {
+    return {
+      body: { user: { id: params.userId, name: "John Doe" } },
+    };
+  }
+);
+
+// Define a POST route with request validation
+app.post(
+  app.noAuth,
+  "/messages",
+  z.object({ content: z.string().min(1) }),
+  z.object({ id: z.string() }),
+  async ({ body }) => {
+    return {
+      body: { id: "msg_123" },
+    };
+  }
+);
+
+// Export the worker handlers
+export default app;
+```
+
+## Authentication
+
+Two-Stroke provides several authentication methods out of the box:
+
+```typescript
+// No authentication
+app.get(app.noAuth, "/public", z.object({ message: z.string() }), async () => ({
+  body: { message: "Public endpoint" },
+}));
+
+// PBKDF authentication
+app.get(
+  app.pbkdf("API_KEY"),
+  "/protected",
+  z.object({ message: z.string() }),
+  async () => ({ body: { message: "Protected endpoint" } })
+);
+
+// JWT authentication
+app.get(
+  app.jwt<{ userId: string }>("JWT_SECRET", "JWT_AUDIENCE"),
+  "/user-data",
+  z.object({ userId: z.string() }),
+  async ({ claims }) => ({ body: { userId: claims.userId } })
+);
+```
+
+## Queue Handling
+
+```typescript
+// Define a queue handler
+app.queueHandler(
+  z.object({ id: z.string() }),
+  async ({ batch, parsedBatch, env }) => {
+    for (let i = 0; i < batch.messages.length; i++) {
+      if (parsedBatch[i].success) {
+        const data = parsedBatch[i].data;
+        // Process queue message
+        console.log(`Processing message: ${data.id}`);
+      }
+    }
+  }
+);
+
+// Add to queue with retry logic
+import { addToQueue } from "two-stroke";
+
+await addToQueue(
+  env.MY_QUEUE,
+  { id: "task_123" },
+  {
+    retries: 3,
+    backoffFactor: 2,
+  }
+);
+```
+
+## Scheduled Tasks
+
+```typescript
+// Define a scheduled task
+app.schedule("*/15 * * * *", async ({ env }) => {
+  // Run every 15 minutes
+  console.log("Running scheduled task");
+});
+```

package/package.json

@@ -8,21 +8,21 @@
     "type-check": "./bin/type-check.mjs"
   },
   "dependencies": {
-    "@anatine/zod-openapi": "^2.2.7",
+    "@anatine/zod-openapi": "^2.2.8",
     "@asteasolutions/zod-to-openapi": "^7.3.0",
-    "@cloudflare/vitest-pool-workers": "^0.8.8",
-    "@cloudflare/workers-types": "^4.20250327.0",
+    "@cloudflare/vitest-pool-workers": "^0.8.17",
+    "@cloudflare/workers-types": "^4.20250416.0",
     "@sentry/cli": "^2.43.0",
-    "@types/node": "^22.13.14",
-    "@typescript-eslint/eslint-plugin": "^8.28.0",
-    "@typescript-eslint/parser": "^8.28.0",
-    "@vitest/coverage-istanbul": "^3.0.9",
-    "eslint-config-prettier": "^10.1.1",
-    "eslint-config-two-stroke": "^1.1.12",
+    "@types/node": "^22.14.1",
+    "@typescript-eslint/eslint-plugin": "^8.30.1",
+    "@typescript-eslint/parser": "^8.30.1",
+    "@vitest/coverage-istanbul": "^3.1.1",
+    "eslint-config-prettier": "^10.1.2",
+    "eslint-config-two-stroke": "^1.1.13",
     "eslint-config-typescript": "^3.0.0",
     "jose": "^6.0.10",
     "jwk-subtle": "^1.0.7",
-    "miniflare": "^4.20250321.1",
+    "miniflare": "^4.20250410.1",
     "openapi-fetch": "^0.13.5",
     "openapi-typescript": "^7.6.1",
     "openapi3-ts": "^4.4.0",
@@ -52,12 +52,12 @@
   "name": "two-stroke",
   "packageManager": "yarn@4.6.0",
   "type": "module",
-  "version": "4.3.0",
+  "version": "4.3.2",
   "devDependencies": {
     "@types/eslint": "^9.6.1",
-    "eslint": "^9.23.0",
+    "eslint": "^9.24.0",
     "prettier": "^3.5.3",
-    "typescript": "^5.8.2",
-    "vitest": "^3.0.9"
+    "typescript": "^5.8.3",
+    "vitest": "^3.1.1"
   }
 }

package/src/open-api.ts

@@ -108,7 +108,7 @@ export const openAPI =
     const generator = new OpenApiGeneratorV31(openAPIRegistry.definitions);
     return {
       body: generator.generateDocument({
-        openapi: "3.1",
+        openapi: "3.1.0",
         info: {
           title,
           version: release,