format with prettier

.github/workflows/node.js.yml

@@ -1,23 +1,17 @@
 name: Run tests
 on:
   push:
-    branches: [ "main" ]
+    branches: ["main"]
   pull_request:
-    branches: [ "main" ]
+    branches: ["main"]
 jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
-    - name: Use Node.js
-      uses: actions/setup-node@v4
-      with:
-        cache-dependency-path: |
-          example/package-lock.json
-          package-lock.json
-        node-version: '18.x'
-        cache: 'npm'
-    - run: npm i
-    - run: npm ci
-    - run: cd example && npm i && cd ..
-    - run: npm test
+      - uses: actions/checkout@v4
+      - name: Use Node.js
+        uses: actions/setup-node@v4
+      - run: npm i
+      - run: npm ci
+      - run: cd example && npm i && cd ..
+      - run: npm test

.prettierrc.json

@@ -0,0 +1,3 @@
+{
+  "trailingComma": "es5"
+}

README.md

@@ -27,7 +27,9 @@ const scrapePool = new Workpool(components.scrapeWorkpool, {
 export const signUp = mutation({
   handler: async (ctx, args) => {
     const userId = await ctx.db.insert("users", args);
-    await emailPool.enqueueAction(internal.auth.sendEmailVerification, { userId });
+    await emailPool.enqueueAction(internal.auth.sendEmailVerification, {
+      userId,
+    });
   },
 });
 

example/README.md

@@ -2,4 +2,3 @@
 
 Components need an app that uses them in order to run codegen. An example app is also useful
 for testing and documentation.
-

example/convex/README.md

@@ -80,7 +80,7 @@ function handleButtonPress() {
   // OR
   // use the result once the mutation has completed
   mutation({ first: "Hello!", second: "me" }).then((result) =>
-    console.log(result),
+    console.log(result)
   );
 }
 ```

example/convex/example.test.ts

@@ -1,15 +1,17 @@
 /// <reference types="vite/client" />
 
 import { convexTest } from "convex-test";
-import { afterEach, beforeEach, describe, expect, test, vi } from "vitest"
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
 import schema from "./schema";
 import componentSchema from "../../src/component/schema";
 import cronsSchema from "../../node_modules/@convex-dev/crons/src/component/schema";
 import { api, components } from "./_generated/api";
 
 const modules = import.meta.glob("./**/*.ts");
 const componentModules = import.meta.glob("../../src/component/**/*.ts");
-const cronsModules = import.meta.glob("../../node_modules/@convex-dev/crons/src/component/**/*.ts");
+const cronsModules = import.meta.glob(
+  "../../node_modules/@convex-dev/crons/src/component/**/*.ts"
+);
 
 describe("workpool", () => {
   async function setupTest() {
@@ -47,16 +49,11 @@ describe("workpool", () => {
   });
 
   test("enqueue and get status", async () => {
-    const id = await t.mutation(api.example.enqueueOneMutation, {data: 1});
+    const id = await t.mutation(api.example.enqueueOneMutation, { data: 1 });
     await runToCompletion();
     expect(await t.query(api.example.status, { id })).toEqual({
       kind: "success",
       result: 1,
     });
-  })
-
-  test("drop in replacement for ctx", async () => {
-    const result = await t.action(api.example.doSomethingInPool, {});
-    expect(result).toEqual(3);
   });
 });

example/convex/example.ts

@@ -3,7 +3,7 @@ import { api, components } from "./_generated/api";
 import { WorkId, WorkPool } from "@convex-dev/workpool";
 import { v } from "convex/values";
 
-const pool = new WorkPool(components.workpool, { 
+const pool = new WorkPool(components.workpool, {
   maxParallelism: 3,
   // For tests, disable completed work cleanup.
   completedWorkMaxAgeMs: Number.POSITIVE_INFINITY,
@@ -20,20 +20,20 @@ export const addMutation = mutation({
   args: { data: v.optional(v.number()) },
   handler: async (ctx, { data }) => {
     const d = data ?? Math.random();
-    await ctx.db.insert("data", {data: d});
+    await ctx.db.insert("data", { data: d });
     return d;
   },
 });
 
 export const addAction = action({
   args: { data: v.optional(v.number()) },
   handler: async (ctx, { data }): Promise<number> => {
-    return await ctx.runMutation(api.example.addMutation, {data});
+    return await ctx.runMutation(api.example.addMutation, { data });
   },
 });
 
 export const enqueueOneMutation = mutation({
-  args: {data: v.number()},
+  args: { data: v.number() },
   handler: async (ctx, { data }): Promise<string> => {
     return await pool.enqueueMutation(ctx, api.example.addMutation, { data });
   },
@@ -43,7 +43,7 @@ export const status = query({
   args: { id: v.string() },
   handler: async (ctx, { id }) => {
     return await pool.status(ctx, id as WorkId<null>);
-  }
+  },
 });
 
 export const enqueueABunchOfMutations = mutation({
@@ -59,7 +59,7 @@ export const addLowPri = mutation({
   args: { data: v.optional(v.number()) },
   handler: async (ctx, { data }) => {
     const d = -(data ?? Math.random());
-    await ctx.db.insert("data", {data: d});
+    await ctx.db.insert("data", { data: d });
     return d;
   },
 });
@@ -86,7 +86,7 @@ export const enqueueAndWait = action({
   args: {},
   handler: async (ctx, _args): Promise<number> => {
     const work = await pool.enqueueAction(ctx, api.example.addAction, {});
-    const result = await pool.pollResult(ctx, work, 30*1000);
+    const result = await pool.pollResult(ctx, work, 30 * 1000);
     return result;
   },
 });
@@ -101,7 +101,7 @@ export const doSomethingInPool = action({
 });
 
 async function doSomething(ctx: ActionCtx): Promise<number> {
-  const data1 = await ctx.runMutation(api.example.addMutation, {data: 1});
-  const data2 = await ctx.runAction(api.example.addAction, {data: 2});
+  const data1 = await ctx.runMutation(api.example.addMutation, { data: 1 });
+  const data2 = await ctx.runAction(api.example.addAction, { data: 2 });
   return data1 + data2;
 }

example/convex/schema.ts

@@ -1,10 +1,8 @@
 import { defineSchema, defineTable } from "convex/server";
 import { v } from "convex/values";
 
-export default defineSchema(
-  {
-    data: defineTable({
-      data: v.number(),
-    }),
-  },
-);
+export default defineSchema({
+  data: defineTable({
+    data: v.number(),
+  }),
+});

node10stubs.mjs

@@ -46,7 +46,7 @@ async function processSubPackages(packageJsonPath, exports, cleanup = false) {
       await fs.mkdir(newDir, { recursive: true });
       await fs.writeFile(
         newPackageJsonPath,
-        JSON.stringify(newPackageJson, null, 2),
+        JSON.stringify(newPackageJson, null, 2)
       );
     }
   }
@@ -71,11 +71,11 @@ async function main() {
 
     if (isCleanup) {
       console.log(
-        "Node10 module resolution compatibility stub directories removed.",
+        "Node10 module resolution compatibility stub directories removed."
       );
     } else {
       console.log(
-        "Node10 module resolution compatibility stub directories created",
+        "Node10 module resolution compatibility stub directories created"
       );
     }
   } catch (error) {

package.json

@@ -28,6 +28,7 @@
     "prepack": "node node10stubs.mjs",
     "postpack": "node node10stubs.mjs --cleanup",
     "test": "vitest run",
+    "format": "prettier --write .",
     "test:debug": "vitest --inspect-brk --no-file-parallelism",
     "test:coverage": "vitest run --coverage --coverage.reporter=text"
   },
@@ -64,7 +65,7 @@
   "devDependencies": {
     "@eslint/js": "^9.9.1",
     "@types/node": "^18.17.0",
-    "convex-test": "file:../convex-test/convex-test-0.0.33.tgz",
+    "convex-test": "^0.0.35-alpha.0",
     "eslint": "^9.9.1",
     "globals": "^15.9.0",
     "prettier": "3.2.5",

src/client/index.ts

@@ -22,45 +22,45 @@ export class WorkPool {
     private options: {
       // How many actions/mutations can be running at once within this pool.
       // Min 1, Max 300.
-      maxParallelism: number,
+      maxParallelism: number;
       // How long an action can run before the pool considers it to be timed out.
       // The action itself might time out earlier.
       // Default 15 minutes.
-      actionTimeoutMs?: number,
+      actionTimeoutMs?: number;
       // How long a mutation can run before the pool considers it to be timed out.
       // The mutation itself might time out earlier.
       // Default 30 seconds.
-      mutationTimeoutMs?: number,
+      mutationTimeoutMs?: number;
       // How long a function started by `enqueueUnknown` or `runAt` or `runAfter`
       // can run before the pool considers it to be timed out.
       // The function itself might time out earlier.
       // Default 15 minutes.
-      unknownTimeoutMs?: number,
+      unknownTimeoutMs?: number;
       // When there is something to do, wait this long between loop iterations,
       // to allow more work to accumulate.
       // Default 50ms.
-      debounceMs?: number,
+      debounceMs?: number;
       // When something is running, wait this long to check if anything has
       // been canceled or failed unexpectedly.
       // Default 10s.
-      fastHeartbeatMs?: number,
+      fastHeartbeatMs?: number;
       // When nothing is happening, wait this long to check if there is new work
       // that we missed.
       // Default 2 hours.
-      slowHeartbeatMs?: number,
+      slowHeartbeatMs?: number;
       // How much to log.
       // Default WARN.
-      logLevel?: LogLevel,
+      logLevel?: LogLevel;
       // How long to keep completed work in the database, for access by `status`,
       // `tryResult`, and `pollResult`.
       // Default 1 day.
-      completedWorkMaxAgeMs?: number,
+      completedWorkMaxAgeMs?: number;
     }
   ) {}
   async enqueueAction<Args extends DefaultFunctionArgs, ReturnType>(
     ctx: RunMutationCtx,
-    fn: FunctionReference<'action', FunctionVisibility, Args, ReturnType>,
-    fnArgs: Args,
+    fn: FunctionReference<"action", FunctionVisibility, Args, ReturnType>,
+    fnArgs: Args
   ): Promise<WorkId<ReturnType>> {
     const handle = await createFunctionHandle(fn);
     const id = await ctx.runMutation(this.component.public.enqueue, {
@@ -74,8 +74,8 @@ export class WorkPool {
   }
   async enqueueMutation<Args extends DefaultFunctionArgs, ReturnType>(
     ctx: RunMutationCtx,
-    fn: FunctionReference<'mutation', FunctionVisibility, Args, ReturnType>,
-    fnArgs: Args,
+    fn: FunctionReference<"mutation", FunctionVisibility, Args, ReturnType>,
+    fnArgs: Args
   ): Promise<WorkId<ReturnType>> {
     const handle = await createFunctionHandle(fn);
     const id = await ctx.runMutation(this.component.public.enqueue, {
@@ -91,16 +91,21 @@ export class WorkPool {
   // which can happen if it comes from `runAt` or `runAfter`.
   async enqueueUnknown<Args extends DefaultFunctionArgs>(
     ctx: RunMutationCtx,
-    fn: FunctionReference<'action' | 'mutation', FunctionVisibility, Args, null>,
+    fn: FunctionReference<
+      "action" | "mutation",
+      FunctionVisibility,
+      Args,
+      null
+    >,
     fnArgs: Args,
-    runAtTime: number,
+    runAtTime: number
   ): Promise<WorkId<null>> {
     const handle = await createFunctionHandle(fn);
     const id = await ctx.runMutation(this.component.public.enqueue, {
       handle,
       options: this.options,
       fnArgs,
-      fnType: 'unknown',
+      fnType: "unknown",
       runAtTime,
     });
     return id as WorkId<null>;
@@ -110,15 +115,18 @@ export class WorkPool {
   }
   async status<ReturnType>(
     ctx: RunQueryCtx,
-    id: WorkId<ReturnType>,
+    id: WorkId<ReturnType>
   ): Promise<
-    { kind: "pending" } | { kind: "inProgress" } | { kind: "success", result: ReturnType } | { kind: "error", error: string }
+    | { kind: "pending" }
+    | { kind: "inProgress" }
+    | { kind: "success"; result: ReturnType }
+    | { kind: "error"; error: string }
   > {
     return await ctx.runQuery(this.component.public.status, { id });
   }
   async tryResult<ReturnType>(
     ctx: RunQueryCtx,
-    id: WorkId<ReturnType>,
+    id: WorkId<ReturnType>
   ): Promise<ReturnType | undefined> {
     const status = await this.status(ctx, id);
     if (status.kind === "success") {
@@ -132,7 +140,7 @@ export class WorkPool {
   async pollResult<ReturnType>(
     ctx: RunQueryCtx & RunActionCtx,
     id: WorkId<ReturnType>,
-    timeoutMs: number,
+    timeoutMs: number
   ): Promise<ReturnType> {
     const start = Date.now();
     while (true) {
@@ -147,16 +155,16 @@ export class WorkPool {
     }
   }
   ctx<DataModel extends GenericDataModel>(
-    ctx: GenericActionCtx<DataModel>,
+    ctx: GenericActionCtx<DataModel>
   ): GenericActionCtx<DataModel> {
     return {
       runAction: (async (action: any, args: any) => {
         const workId = await this.enqueueAction(ctx, action, args);
-        return this.pollResult(ctx, workId, 30*1000);
+        return this.pollResult(ctx, workId, 30 * 1000);
       }) as any,
       runMutation: (async (mutation: any, args: any) => {
         const workId = await this.enqueueMutation(ctx, mutation, args);
-        return this.pollResult(ctx, workId, 30*1000);
+        return this.pollResult(ctx, workId, 30 * 1000);
       }) as any,
       scheduler: {
         runAfter: async (delay: number, fn: any, args: any) => {
@@ -167,7 +175,7 @@ export class WorkPool {
         },
         cancel: async (id: any) => {
           await this.cancel(ctx, id);
-        }
+        },
       } as any,
       auth: ctx.auth,
       storage: ctx.storage,

src/component/convex.config.ts

@@ -5,4 +5,4 @@ const component = defineComponent("workpool");
 
 component.use(crons);
 
-export default component;
+export default component;

src/component/logging.ts

@@ -6,7 +6,7 @@ export const logLevel = v.union(
   v.literal("DEBUG"),
   v.literal("INFO"),
   v.literal("WARN"),
-  v.literal("ERROR"),
+  v.literal("ERROR")
 );
 export type LogLevel = Infer<typeof logLevel>;