two-stroke 7.3.0 → 7.5.0

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,13 +16,13 @@ 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,
+        key: entry.includes(ent.name) ? `${process.env.DOMAIN}${key}` : key,
         value: (
           await fs.promises.readFile(`${ent.parentPath}/${ent.name}`)
         ).toString("base64"),
@@ -35,14 +35,14 @@ const files = await Promise.all(
                 ? "text/javascript;charset=utf-8"
                 : type,
           "Cache-Control":
-            ent.name === entry ? "nocache" : "max-age=31536000, immutable",
+            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/type-check.mjs

@@ -4,7 +4,22 @@ import fs from "fs";
 import { cmd } from "../src/cmd.mjs";
 
 if (fs.existsSync("wrangler.jsonc")) {
-    cmd("wrangler types --strict-vars false")
+  const devVarsFiles = fs.globSync("**/.dev.vars");
+  const backed = [];
+
+  for (const file of devVarsFiles) {
+    const tmp = file + ".bak.bak";
+    fs.renameSync(file, tmp);
+    backed.push({ original: file, tmp });
+  }
+
+  try {
+    cmd("wrangler types --strict-vars false");
+  } finally {
+    for (const { original, tmp } of backed) {
+      fs.renameSync(tmp, original);
+    }
+  }
 }
 cmd("wrangler deploy --env=  --dry-run --outdir=dist");
 cmd("tsc --noEmit");

package/package.json

@@ -10,7 +10,7 @@
     "type-check": "./bin/type-check.mjs"
   },
   "dependencies": {
-    "@cloudflare/vitest-pool-workers": "^0.13.5",
+    "@cloudflare/vitest-pool-workers": "^0.14.1",
     "@sentry/cli": "^3.3.4",
     "@types/node": "^25.5.0",
     "@typescript-eslint/eslint-plugin": "^8.57.2",
@@ -59,7 +59,7 @@
     "url": "https://github.com/change-engine/two-stroke"
   },
   "type": "module",
-  "version": "7.3.0",
+  "version": "7.5.0",
   "devDependencies": {
     "@types/eslint": "^9.6.1",
     "eslint": "^10.1.0",

package/src/once.ts

@@ -0,0 +1,128 @@
+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>,
+) => {
+    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());
+                },
+            );
+
+            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;
+
+            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));
+        }
+    }
+    throw new Error(`Failed to put ${key} to R2`);
+};