two-stroke 7.4.0 → 7.6.0

package/.github/workflows/dependabot.yml

@@ -16,7 +16,7 @@ jobs:
     steps:
       - name: Dependabot metadata
         id: metadata
-        uses: dependabot/fetch-metadata@v3.0.0
+        uses: dependabot/fetch-metadata@v3.1.0
         with:
           github-token: "${{ secrets.GITHUB_TOKEN }}"
       - name: Approve a PR

package/bin/api-types.mjs

@@ -7,9 +7,7 @@ import ts from "typescript";
 
 const services = process.argv[2].split(",");
 
-const UUID = ts.factory.createTypeReferenceNode(
-  ts.factory.createIdentifier("UUID"),
-);
+const UUID = ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("UUID"));
 const NULL = ts.factory.createLiteralTypeNode(ts.factory.createNull());
 
 await Promise.all(
@@ -17,9 +15,7 @@ await Promise.all(
     const output = await openapiTS(`${service}/doc`, {
       transform(schemaObject) {
         if ("format" in schemaObject && schemaObject.format === "uuid") {
-          return schemaObject.nullable
-            ? ts.factory.createUnionTypeNode([UUID, NULL])
-            : UUID;
+          return schemaObject.nullable ? ts.factory.createUnionTypeNode([UUID, NULL]) : UUID;
         }
       },
     });
@@ -29,11 +25,7 @@ await Promise.all(
       "",
       ts.ScriptTarget.Latest,
     );
-    const result = printer.printNode(
-      ts.EmitHint.Unspecified,
-      output[0],
-      resultFile,
-    );
+    const result = printer.printNode(ts.EmitHint.Unspecified, output[0], resultFile);
     fs.writeFileSync(
       `src/__definitions__/${service.replace("https://", "")}-definitions.ts`,
       await prettier.format(

package/bin/bulk.mjs

@@ -6,7 +6,7 @@ import { cmd } from "../src/cmd.mjs";
 import mime from "mime";
 
 const entryOrRest = process.argv[2];
-const entry = process.argv[3];
+const entry = process.argv.slice(3);
 
 const ents = await fs.promises.readdir("dist", {
   withFileTypes: true,
@@ -16,16 +16,14 @@ const files = await Promise.all(
   ents
     .filter((ent) => ent.isFile())
     .filter((ent) =>
-      entryOrRest == "entry" ? ent.name === entry : ent.name !== entry,
+      entryOrRest == "entry" ? entry.includes(ent.name) : !entry.includes(ent.name),
     )
     .map((ent) => {
       const type = mime.getType(`${ent.parentPath}/${ent.name}`);
       const key = `${ent.parentPath.substring(4)}/${ent.name}`;
       return (async () => ({
-        key: ent.name === entry ? `${process.env.DOMAIN}${key}` : key,
-        value: (
-          await fs.promises.readFile(`${ent.parentPath}/${ent.name}`)
-        ).toString("base64"),
+        key: entry.includes(ent.name) ? `${process.env.DOMAIN}${key}` : key,
+        value: (await fs.promises.readFile(`${ent.parentPath}/${ent.name}`)).toString("base64"),
         base64: true,
         metadata: {
           "Content-Type":
@@ -34,15 +32,14 @@ const files = await Promise.all(
               : type === "text/javascript"
                 ? "text/javascript;charset=utf-8"
                 : type,
-          "Cache-Control":
-            ent.name === entry ? "nocache" : "max-age=31536000, immutable",
+          "Cache-Control": entry.includes(ent.name) ? "nocache" : "max-age=31536000, immutable",
         },
       }))();
     }),
 );
 
-fs.writeFileSync(`dist/bulk_${process.argv[2]}.json`, JSON.stringify(files));
+fs.writeFileSync(`dist/bulk_${entryOrRest}.json`, JSON.stringify(files));
 
 cmd(
-  `wrangler kv bulk put dist/bulk_${process.argv[2]}.json --remote --namespace-id ${process.env.NAMESPACE}`,
+  `wrangler kv bulk put dist/bulk_${entryOrRest}.json --remote --namespace-id ${process.env.NAMESPACE}`,
 );

package/bin/lint.mjs

@@ -4,7 +4,7 @@ import fs from "fs";
 import { cmd } from "../src/cmd.mjs";
 
 if (fs.existsSync("wrangler.jsonc")) {
-    cmd("wrangler types --strict-vars false --check")
+  cmd("wrangler types --strict-vars false --check");
 }
 cmd("eslint --cache --max-warnings=0");
 cmd("prettier --cache --check .");

package/bin/test.mjs

@@ -25,11 +25,7 @@ if (fs.existsSync("wrangler.jsonc")) {
   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 resultFile = ts.createSourceFile("test/api.d.ts", "", ts.ScriptTarget.Latest);
     const result = types
       .map((t) => printer.printNode(ts.EmitHint.Unspecified, t, resultFile))
       .join("\n\n");
@@ -40,8 +36,7 @@ if (fs.existsSync("wrangler.jsonc")) {
   }
 }
 cmd("vitest", [
-  ...(!process.argv.slice(2).includes("-w") &&
-    !process.argv.slice(2).includes("--watch")
+  ...(!process.argv.slice(2).includes("-w") && !process.argv.slice(2).includes("--watch")
     ? ["--run"]
     : []),
   ...process.argv.slice(2),

package/package.json

@@ -10,10 +10,10 @@
     "type-check": "./bin/type-check.mjs"
   },
   "dependencies": {
-    "@cloudflare/vitest-pool-workers": "^0.14.1",
+    "@cloudflare/vitest-pool-workers": "^0.15.2",
     "@sentry/cli": "^3.3.4",
     "@types/node": "^25.5.0",
-    "@typescript-eslint/eslint-plugin": "^8.57.2",
+    "@typescript-eslint/eslint-plugin": "^8.59.1",
     "@typescript-eslint/parser": "^8.57.2",
     "@vitest/runner": "^4.1.2",
     "@vitest/snapshot": "^4.1.2",
@@ -29,7 +29,7 @@
     "openapi-typescript": "^7.13.0",
     "pbkdf-subtle": "^1.1.5",
     "toucan-js": "^4.1.1",
-    "zod": "^4.3.6"
+    "zod": "^4.4.2"
   },
   "peerDependencies": {
     "@sentry/cli": ">=2",
@@ -59,7 +59,7 @@
     "url": "https://github.com/change-engine/two-stroke"
   },
   "type": "module",
-  "version": "7.4.0",
+  "version": "7.6.0",
   "devDependencies": {
     "@types/eslint": "^9.6.1",
     "eslint": "^10.1.0",

package/src/fake.ts

@@ -1,3 +1,3 @@
 import { twoStroke } from ".";
 
-export default twoStroke("fake", "0.1")
+export default twoStroke("fake", "0.1");

package/src/index.ts

@@ -3,15 +3,14 @@ import { verify as pbkdfVerify } from "pbkdf-subtle";
 import { Toucan } from "toucan-js";
 import { type ZodSafeParseResult, z, ZodObject, ZodType } from "zod/v4";
 import { openAPI } from "./open-api";
-import { type Env, type Handler, type Route } from "./types";
+import { type Handler, type Route } from "./types";
 
 // eslint-disable-next-line @typescript-eslint/require-await
 const noAuth = async () => null;
 
-const escapeRegex = (str: string) =>
-  str.replace(/([.*+?^=!:$()|[\]\\])/g, "\\$&");
+const escapeRegex = (str: string) => str.replace(/([.*+?^=!:$()|[\]\\])/g, "\\$&");
 
-export function twoStroke<T extends Env>(
+export function twoStroke<T>(
   title: string,
   release: string,
   origin?: (o: string | null) => string,
@@ -35,11 +34,7 @@ export function twoStroke<T extends Env>(
   const crons: {
     [cron: string]: (c: { env: T; sentry: Toucan }) => Promise<void>;
   } = {};
-  let _email: (c: {
-    message: ForwardableEmailMessage;
-    env: T;
-    sentry: Toucan;
-  }) => Promise<void>;
+  let _email: (c: { message: ForwardableEmailMessage; env: T; sentry: Toucan }) => Promise<void>;
   return {
     async fetch(
       req: Request,
@@ -85,9 +80,10 @@ export function twoStroke<T extends Env>(
         for (const route of routes) {
           if (req.method === route.method && route.matcher.test(pathname)) {
             const params = Object.fromEntries(
-              Object.entries(pathname.match(route.matcher)?.groups ?? {}).map(
-                ([k, v]) => [k, decodeURIComponent(v)],
-              ),
+              Object.entries(pathname.match(route.matcher)?.groups ?? {}).map(([k, v]) => [
+                k,
+                decodeURIComponent(v),
+              ]),
             );
             let claims;
             try {
@@ -108,8 +104,7 @@ export function twoStroke<T extends Env>(
               let rawBody;
               try {
                 rawBody = route.input
-                  ? req.headers.get("Content-Type") ===
-                    "application/x-www-form-urlencoded"
+                  ? req.headers.get("Content-Type") === "application/x-www-form-urlencoded"
                     ? Object.fromEntries(new URLSearchParams(await req.text()))
                     : await req.json()
                   : undefined;
@@ -132,10 +127,10 @@ export function twoStroke<T extends Env>(
               const body = route.input
                 ? route.input.safeParse(rawBody)
                 : {
-                  success: true,
-                  data: undefined,
-                  error: undefined,
-                };
+                    success: true,
+                    data: undefined,
+                    error: undefined,
+                  };
               if (body.success)
                 response = await route.handler({
                   req,
@@ -199,19 +194,16 @@ export function twoStroke<T extends Env>(
             Object.entries({
               ...defaultHeaders,
               "Content-Type": "application/json",
-              "Strict-Transport-Security":
-                "max-age=15552000; includeSubDomains",
+              "Strict-Transport-Security": "max-age=15552000; includeSubDomains",
               "X-Content-Type-Options": "nosniff",
               "Content-Security-Policy": "default-src 'self'",
             }).forEach(([k, v]) => {
-              if (!responseWithHeaders.headers.has(k))
-                responseWithHeaders.headers.set(k, v);
+              if (!responseWithHeaders.headers.has(k)) responseWithHeaders.headers.set(k, v);
             });
 
             return new Response(
               // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-              responseWithHeaders.headers.get("Content-Type") ===
-                "application/json"
+              responseWithHeaders.headers.get("Content-Type") === "application/json"
                 ? JSON.stringify(response.body)
                 : response.body,
               responseWithHeaders,
@@ -300,53 +292,38 @@ export function twoStroke<T extends Env>(
       }
     },
     emailHandler(
-      handler: (c: {
-        env: T;
-        message: ForwardableEmailMessage;
-        sentry: Toucan;
-      }) => Promise<void>,
+      handler: (c: { env: T; message: ForwardableEmailMessage; sentry: Toucan }) => Promise<void>,
     ) {
       _email = handler;
     },
-    schedule(
-      cron: string,
-      handler: (c: { env: T; sentry: Toucan }) => Promise<void>,
-    ) {
+    schedule(cron: string, handler: (c: { env: T; sentry: Toucan }) => Promise<void>) {
       crons[cron] = handler;
     },
     noAuth,
     pbkdf:
       (k: keyof T, customHeaderName: string = "Authorization") =>
-        async ({ req, env }: { req: Request; env: T }) => {
-          const [scheme, token] = (
-            req.headers.get(customHeaderName) ?? " "
-          ).split(" ");
-          if (
-            (scheme === "token" || scheme === "Bearer") &&
-            (await pbkdfVerify(env[k] as string, token ?? ""))
-          )
-            return;
-          throw Error("Invalid");
-        },
+      async ({ req, env }: { req: Request; env: T }) => {
+        const [scheme, token] = (req.headers.get(customHeaderName) ?? " ").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;
+      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");
           }
-          throw Error("Invalid");
-        },
+          return claims;
+        }
+        throw Error("Invalid");
+      },
     queueHandler<I extends ZodType>(
       input: I,
       handler: (c: {
@@ -387,9 +364,7 @@ export function twoStroke<T extends Env>(
         auth,
         method: "PUT",
         path,
-        matcher: new RegExp(
-          `^${escapeRegex(path).replaceAll(/\/{([^}]*)}/g, "/(?<$1>[^\\/]*)")}$`,
-        ),
+        matcher: new RegExp(`^${escapeRegex(path).replaceAll(/\/{([^}]*)}/g, "/(?<$1>[^\\/]*)")}$`),
         input,
         output,
         handler,
@@ -415,9 +390,7 @@ export function twoStroke<T extends Env>(
         auth,
         method: "POST",
         path,
-        matcher: new RegExp(
-          `^${escapeRegex(path).replaceAll(/\/{([^}]*)}/g, "/(?<$1>[^\\/]*)")}$`,
-        ),
+        matcher: new RegExp(`^${escapeRegex(path).replaceAll(/\/{([^}]*)}/g, "/(?<$1>[^\\/]*)")}$`),
         input,
         output,
         handler,
@@ -442,9 +415,7 @@ export function twoStroke<T extends Env>(
         auth,
         method: "GET",
         path,
-        matcher: new RegExp(
-          `^${escapeRegex(path).replaceAll(/\/{([^}]*)}/g, "/(?<$1>[^\\/]*)")}$`,
-        ),
+        matcher: new RegExp(`^${escapeRegex(path).replaceAll(/\/{([^}]*)}/g, "/(?<$1>[^\\/]*)")}$`),
         output,
         handler,
         params,
@@ -467,9 +438,7 @@ export function twoStroke<T extends Env>(
         auth,
         method: "DELETE",
         path,
-        matcher: new RegExp(
-          `^${escapeRegex(path).replaceAll(/\/{([^}]*)}/g, "/(?<$1>[^\\/]*)")}$`,
-        ),
+        matcher: new RegExp(`^${escapeRegex(path).replaceAll(/\/{([^}]*)}/g, "/(?<$1>[^\\/]*)")}$`),
         output,
         handler,
         params,
@@ -483,11 +452,7 @@ type AddToQueueConfig = QueueSendOptions & {
   backoffFactor?: number;
 };
 
-export async function addToQueue<T>(
-  queue: Queue<T>,
-  message: T,
-  config: AddToQueueConfig = {},
-) {
+export async function addToQueue<T>(queue: Queue<T>, message: T, config: AddToQueueConfig = {}) {
   const { retries, backoffFactor, ...options } = config;
 
   for (let i = 0; i < (retries ?? 5); i++) {

package/src/once.ts

@@ -1,128 +1,126 @@
 import type { z, ZodSafeParseResult, ZodType } from "zod/v4";
 
 export const once = async <T extends { retry_count: number }>(
-    key: string,
-    bucket: R2Bucket,
-    queue: Queue<T>,
-    backoffExponent: number,
-    numRetries: number,
-    ack: (cb: () => Promise<void>) => Promise<void>,
-    cb: (retry: (m: T) => Promise<void>) => Promise<void>,
+  key: string,
+  bucket: R2Bucket,
+  queue: Queue<T>,
+  backoffExponent: number,
+  numRetries: number,
+  ack: (cb: () => Promise<void>) => Promise<void>,
+  cb: (retry: (m: T) => Promise<void>) => Promise<void>,
 ) => {
-    const retry = async (m: T) => {
-        const retry_count = m.retry_count + 1;
-        if (retry_count > numRetries) throw new Error("Too many retries");
-        await queue.send(
-            { ...m, retry_count },
-            { delaySeconds: Math.min(Math.pow(retry_count, backoffExponent), 900) },
-        );
-    };
-    if (!(await isDuplicateMessage(key, bucket)))
-        await ack(async () => {
-            await cb(retry);
-        });
+  const retry = async (m: T) => {
+    const retry_count = m.retry_count + 1;
+    if (retry_count > numRetries) throw new Error("Too many retries");
+    await queue.send(
+      { ...m, retry_count },
+      { delaySeconds: Math.min(Math.pow(retry_count, backoffExponent), 900) },
+    );
+  };
+  if (!(await isDuplicateMessage(key, bucket)))
+    await ack(async () => {
+      await cb(retry);
+    });
 };
 
-
 export const retryHandler =
-    <T, M extends ZodType>(
-        maxRetries: number,
-        handler: (
-            body: z.output<M>,
-            env: T,
-            isFinalAttempt: boolean,
-            ack: (cb: () => Promise<void>) => Promise<void>,
-        ) => Promise<void>,
-    ) =>
-        async ({
-            body,
-            waitUntil,
-            env,
-        }: {
-            body: z.infer<M> & { retry: number };
-            waitUntil: (p: Promise<void>) => void;
-            env: T;
-        }) => {
-            const isFinalAttempt = body.retry >= maxRetries;
-            await handler(
-                body,
-                env,
-                isFinalAttempt,
-                // eslint-disable-next-line @typescript-eslint/require-await
-                async (cb) => {
-                    waitUntil(cb());
-                },
-            );
+  <T, M extends ZodType>(
+    maxRetries: number,
+    handler: (
+      body: z.output<M>,
+      env: T,
+      isFinalAttempt: boolean,
+      ack: (cb: () => Promise<void>) => Promise<void>,
+    ) => Promise<void>,
+  ) =>
+  async ({
+    body,
+    waitUntil,
+    env,
+  }: {
+    body: z.infer<M> & { retry: number };
+    waitUntil: (p: Promise<void>) => void;
+    env: T;
+  }) => {
+    const isFinalAttempt = body.retry >= maxRetries;
+    await handler(
+      body,
+      env,
+      isFinalAttempt,
+      // eslint-disable-next-line @typescript-eslint/require-await
+      async (cb) => {
+        waitUntil(cb());
+      },
+    );
 
-            return { body: { ok: true } };
-        };
+    return { body: { ok: true } };
+  };
 
 export const retryQueue =
-    <T, M extends ZodType>(
-        maxRetries: number,
-        handler: (
-            body: z.output<M>,
-            env: T,
-            isFinalAttempt: boolean,
-            ack: (cb: () => Promise<void>) => Promise<void>,
-        ) => Promise<void>,
-    ) =>
-        async ({
-            batch,
-            parsedBatch,
-            env,
-        }: {
-            batch: MessageBatch<z.input<M>>;
-            parsedBatch: ZodSafeParseResult<z.output<M>>[];
-            env: T;
-        }) => {
-            const message = batch.messages[0];
-            if (!message || batch.messages.length !== 1) {
-                console.warn({ batch });
-                throw new Error(
-                    `Queue must only process one message at a time, got ${batch.messages.length}`,
-                );
-            }
-            if (!parsedBatch[0] || !parsedBatch[0].success) {
-                console.error({ batch });
-                throw new Error(`Queue message invalid`);
-            }
-
-            const isFinalAttempt = message.attempts >= maxRetries;
+  <T, M extends ZodType>(
+    maxRetries: number,
+    handler: (
+      body: z.output<M>,
+      env: T,
+      isFinalAttempt: boolean,
+      ack: (cb: () => Promise<void>) => Promise<void>,
+    ) => Promise<void>,
+  ) =>
+  async ({
+    batch,
+    parsedBatch,
+    env,
+  }: {
+    batch: MessageBatch<z.input<M>>;
+    parsedBatch: ZodSafeParseResult<z.output<M>>[];
+    env: T;
+  }) => {
+    const message = batch.messages[0];
+    if (!message || batch.messages.length !== 1) {
+      console.warn({ batch });
+      throw new Error(
+        `Queue must only process one message at a time, got ${batch.messages.length}`,
+      );
+    }
+    if (!parsedBatch[0] || !parsedBatch[0].success) {
+      console.error({ batch });
+      throw new Error(`Queue message invalid`);
+    }
 
-            try {
-                await handler(parsedBatch[0].data, env, isFinalAttempt, async (cb) => {
-                    message.ack();
-                    await cb();
-                });
-            } catch (err) {
-                if (!isFinalAttempt) message.retry();
-                throw err;
-            }
-        };
+    const isFinalAttempt = message.attempts >= maxRetries;
 
+    try {
+      await handler(parsedBatch[0].data, env, isFinalAttempt, async (cb) => {
+        message.ack();
+        await cb();
+      });
+    } catch (err) {
+      if (!isFinalAttempt) message.retry();
+      throw err;
+    }
+  };
 
 const isDuplicateMessage = async (key: string, bucket: R2Bucket) => {
-    // Work around for CloudFlare R2 error:
-    // put: We encountered an internal error. Please try again. (10001)
-    for (let i = 0; i < 5; i++) {
-        try {
-            // Will throw if that error occurs
-            const putResult = await bucket.put(`lock-${key}`, "", {
-                onlyIf: new Headers({
-                    "If-Unmodified-Since": "Wed, 21 Oct 2015 07:28:00 GMT",
-                }),
-            });
-            // if the returned result is null then the object already existed
-            const isDupe = putResult === null;
-            if (isDupe) console.log("Duplicate message", { key });
-            return isDupe;
-        } catch (err) {
-            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-            console.warn(`Error putting ${key} to R2: ${err}`);
-            console.warn(`Retrying in ${i} seconds`);
-            await new Promise((resolve) => setTimeout(resolve, i * 1000));
-        }
+  // Work around for CloudFlare R2 error:
+  // put: We encountered an internal error. Please try again. (10001)
+  for (let i = 0; i < 5; i++) {
+    try {
+      // Will throw if that error occurs
+      const putResult = await bucket.put(`lock-${key}`, "", {
+        onlyIf: new Headers({
+          "If-Unmodified-Since": "Wed, 21 Oct 2015 07:28:00 GMT",
+        }),
+      });
+      // if the returned result is null then the object already existed
+      const isDupe = putResult === null;
+      if (isDupe) console.log("Duplicate message", { key });
+      return isDupe;
+    } catch (err) {
+      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+      console.warn(`Error putting ${key} to R2: ${err}`);
+      console.warn(`Retrying in ${i} seconds`);
+      await new Promise((resolve) => setTimeout(resolve, i * 1000));
     }
-    throw new Error(`Failed to put ${key} to R2`);
-};
+  }
+  throw new Error(`Failed to put ${key} to R2`);
+};