lint

ianmacartney · ianmacartney · commit b79202d6140b · 2025-07-09T15:00:26.000-07:00
diff --git a/convex/example.test.ts b/convex/example.test.ts
@@ -17,10 +17,10 @@ describe("testingExample", () => {
     expect(await t.query(api.counter.getCounter, { counterName: "foo" })).toBe(
       0,
     );
-    expect(() =>
+    await expect(
       t.query(api.counter.getCounterOrThrow, { counterName: "foo" }),
     ).rejects.toThrow(/Counter not found/);
-    expect(() =>
+    await expect(() =>
       t.query(api.counter.getCounterOrThrow, { counterName: "bar" }),
     ).rejects.toThrow(/Counter not found/);
     await t.mutation(api.counter.incrementCounter, {
diff --git a/convex/migrationsExample.ts b/convex/migrationsExample.ts
@@ -40,7 +40,7 @@ export const cleanUpBrokenRefs = migration({
 
 export const callOneDirectly = internalMutation({
   args: {},
-  handler: async (ctx, args) => {
+  handler: async (ctx, _args) => {
     // can run a migration directly within a function:
     await startMigration(ctx, internal.migrationsExample.increment, {
       startCursor: null,
diff --git a/convex/retriesExample.ts b/convex/retriesExample.ts
@@ -28,7 +28,7 @@ export const unreliableAction = internalAction({
 // e.g. `npx convex run retriesExample:runUnreliableActionWithRetries`
 export const runUnreliableActionWithRetries = mutation({
   args: {},
-  handler: async (ctx, args) => {
+  handler: async (ctx, _args) => {
     await runWithRetries(ctx, internal.retriesExample.unreliableAction, {
       failureRate: 0.8,
     });
diff --git a/convex/sessionsExample.ts b/convex/sessionsExample.ts
@@ -138,7 +138,7 @@ export const logIn = mutationWithSession({
 
 export const logOut = mutationWithSession({
   args: {},
-  handler: async (ctx, args) => {
+  handler: async (ctx, _args) => {
     console.log("deleting presence data on logout", ctx.sessionId);
     const presenceDocs = await ctx.db
       .query("presence")
diff --git a/convex/triggersExample.ts b/convex/triggersExample.ts
@@ -97,7 +97,7 @@ export const incrementCounterRace = mutation({
 
 export const getSum = query({
   args: {},
-  handler: async (ctx, args) => {
+  handler: async (ctx, _args) => {
     return ctx.db.query("sum_table").first();
   },
 });
diff --git a/eslint.config.mjs b/eslint.config.mjs
@@ -5,11 +5,16 @@ import reactPlugin from "eslint-plugin-react";
 import reactHooks from "eslint-plugin-react-hooks";
 
 export default [
-  { files: ["src/**/*.{js,mjs,cjs,ts,tsx}"] },
+  { files: ["src/**/*.{js,mjs,cjs,ts,tsx}", "convex/**/*.{ts,tsx}"] },
   {
     ignores: [
       "dist/**",
+      "packages/convex-helpers/dist/**",
+      "packages/convex-helpers/generate-exports.mjs",
+      "src/fakeConvexClient/fakeConvexClient.js",
+      "backendHarness.js",
       "eslint.config.mjs",
+      "convex/vitest.config.mts",
       "setup.cjs",
       "**/_generated/",
       "vite.config.mts",
diff --git a/packages/convex-helpers/cli/openApiSpec.test.ts b/packages/convex-helpers/cli/openApiSpec.test.ts
@@ -23,7 +23,7 @@ test("generateValidSpec", async () => {
   const testFileName = "openApiSpec.test.yaml";
   fs.writeFileSync(testFileName, apiSpec, "utf-8");
 
-  let output = execSync(`npx redocly lint ${testFileName} --format='json'`);
+  const output = execSync(`npx redocly lint ${testFileName} --format='json'`);
 
   fs.unlinkSync(testFileName);
 
diff --git a/packages/convex-helpers/cli/openApiSpec.ts b/packages/convex-helpers/cli/openApiSpec.ts
@@ -35,7 +35,7 @@ export const openApiSpec = new Command("open-api-spec")
     ).default(undefined),
   )
   .action(async (options) => {
-    let content = getFunctionSpec(options.prod, options.inputFile);
+    const content = getFunctionSpec(options.prod, options.inputFile);
     const outputPath =
       (options.outputFile ?? `convex-spec-${Date.now().valueOf()}`) + ".yaml";
 
diff --git a/packages/convex-helpers/cli/tsApiSpec.ts b/packages/convex-helpers/cli/tsApiSpec.ts
@@ -37,7 +37,7 @@ export const tsApiSpec = new Command("ts-api-spec")
     ).default(false),
   )
   .action(async (options) => {
-    let content = getFunctionSpec(options.prod, options.inputFile);
+    const content = getFunctionSpec(options.prod, options.inputFile);
     const outputPath =
       (options.outputFile ?? `convexApi${Date.now().valueOf()}`) + ".ts";
 
diff --git a/packages/convex-helpers/index.ts b/packages/convex-helpers/index.ts
@@ -114,9 +114,9 @@ export function withoutSystemFields<T extends Record<string, any>>(obj: T) {
 }
 
 // Type utils:
-const error = Symbol();
+const _error = Symbol();
 export type ErrorMessage<Reason extends string> = Reason & {
-  __error: typeof error;
+  __error: typeof _error;
 };
 
 // Copied from convex/server since it wasn't exported
diff --git a/packages/convex-helpers/react/sessions.ts b/packages/convex-helpers/react/sessions.ts
@@ -70,7 +70,7 @@ const SessionContext = React.createContext<{
 
 type SessionFunction<
   T extends "query" | "mutation" | "action",
-  Args extends any = any,
+  Args = any,
 > = FunctionReference<T, "public", { sessionId: SessionId } & Args, any>;
 
 export type SessionQueryArgsArray<Fn extends SessionFunction<"query">> =
diff --git a/packages/convex-helpers/server/cors.test.ts b/packages/convex-helpers/server/cors.test.ts
@@ -149,7 +149,7 @@ describe("corsRouter internals", () => {
   test("accepts allowedOrigins as a function", async () => {
     const http = new HttpRouter();
     const cors = corsRouter(http, {
-      allowedOrigins: async (request) => {
+      allowedOrigins: async (_) => {
         return ["https://example.com"];
       },
     });
diff --git a/packages/convex-helpers/server/crud.test.ts b/packages/convex-helpers/server/crud.test.ts
@@ -73,22 +73,22 @@ test("crud for table", async () => {
 
 const customQ = customQuery(
   internalQuery,
-  customCtx((ctx) => ({ foo: "bar" })),
+  customCtx((_ctx) => ({ foo: "bar" })),
 );
 const customM = customMutation(
   internalMutation,
-  customCtx((ctx) => ({})),
+  customCtx((_ctx) => ({})),
 );
 
-const customCrud = crud(schema, CrudTable, customQ, customM);
+const _customCrud = crud(schema, CrudTable, customQ, customM);
 
 const customTestApi: ApiFromModules<{
   fns: {
-    create: typeof customCrud.create;
-    read: typeof customCrud.read;
-    update: typeof customCrud.update;
-    paginate: typeof customCrud.paginate;
-    destroy: typeof customCrud.destroy;
+    create: typeof _customCrud.create;
+    read: typeof _customCrud.read;
+    update: typeof _customCrud.update;
+    paginate: typeof _customCrud.paginate;
+    destroy: typeof _customCrud.destroy;
   };
 }>["fns"] = anyApi["crud.test"] as any;
 
diff --git a/packages/convex-helpers/server/customFunctions.test.ts b/packages/convex-helpers/server/customFunctions.test.ts
@@ -136,15 +136,15 @@ async function getUserByTokenIdentifier(ctx: {
 
 customQuery(
   query,
-  customCtx((ctx) => ({ foo: "bar" })),
+  customCtx((_ctx) => ({ foo: "bar" })),
 ) satisfies typeof query;
 customMutation(
   mutation,
-  customCtx((ctx) => ({})),
+  customCtx((_ctx) => ({})),
 ) satisfies typeof mutation;
 customAction(
   action,
-  customCtx((ctx) => ({})),
+  customCtx((_ctx) => ({})),
 ) satisfies typeof action;
 
 /**
@@ -168,6 +168,7 @@ export const addC = addCtxArg({
   },
 });
 queryMatches(addC, {}, { ctxA: "" });
+
 // Unvalidated
 export const addCU = addCtxArg({
   handler: async (ctx) => {
@@ -184,7 +185,7 @@ queryMatches(addCU2, {}, { ctxA: "" });
 
 // Unvalidated with type annotation
 export const addCU3 = addCtxArg({
-  handler: async (ctx, args: { foo: number }) => {
+  handler: async (ctx, _args: { foo: number }) => {
     return { ctxA: ctx.a }; // !!!
   },
 });
@@ -237,7 +238,7 @@ const consumeArg = customQuery(query, {
 export const consume = consumeArg({
   args: {},
   handler: async (ctx, emptyArgs) => {
-    assertType<{}>(emptyArgs); // !!!
+    assertType<Record<string, never>>(emptyArgs); // !!!
     return { ctxA: ctx.a };
   },
 });
@@ -345,17 +346,17 @@ const outerAdder = customQuery(inner, {
 export const outerAdds = outerAdder({
   args: { a: v.string() },
   handler: async (ctx, args) => {
-    return { ctxInner: ctx["inner"], ctxOuter: ctx.outer, ...args };
+    return { ctxInner: (ctx as any)["inner"], ctxOuter: ctx.outer, ...args };
   },
 });
 export const outerRemover = customQuery(inner, {
   args: { outer: v.string() },
-  input: async (_ctx, args) => ({ ctx: { inner: undefined }, args: {} }),
+  input: async (_ctx, _args) => ({ ctx: { inner: undefined }, args: {} }),
 });
-export const outerRemoves = outerRemover({
+export const outerRemoved = outerRemover({
   args: { a: v.string() },
   handler: async (ctx, args) => {
-    return { ctxInner: ctx["inner"], ctxOuter: ctx["outer"], ...args };
+    return { ctxInner: ctx["inner"], ...args };
   },
 });
 
@@ -387,7 +388,7 @@ const testApi: ApiFromModules<{
     badRedefine: typeof badRedefine;
     create: typeof create;
     outerAdds: typeof outerAdds;
-    outerRemoves: typeof outerRemoves;
+    outerRemoved: typeof outerRemoved;
   };
 }>["fns"] = anyApi["customFunctions.test"] as any;
 
@@ -556,9 +557,10 @@ describe("nested custom functions", () => {
   test("remove args", async () => {
     const t = convexTest(schema, modules);
     expect(
-      await t.query(testApi.outerRemoves, { a: "hi", outer: "bye" }),
+      await t.query(testApi.outerRemoved, { a: "hi", outer: "bye" }),
     ).toMatchObject({
       a: "hi",
+      ctxInner: undefined,
     });
   });
 
diff --git a/packages/convex-helpers/server/rateLimit.ts b/packages/convex-helpers/server/rateLimit.ts
@@ -224,10 +224,9 @@ export const rateLimitTables = {
 };
 
 // A data model that includes the rate limit table.
-export interface RateLimitDataModel
-  extends DataModelFromSchemaDefinition<
-    SchemaDefinition<typeof rateLimitTables, true>
-  > {}
+export type RateLimitDataModel = DataModelFromSchemaDefinition<
+  SchemaDefinition<typeof rateLimitTables, true>
+>;
 
 /**
  *
@@ -256,7 +255,7 @@ export function defineRateLimits<
     >(
       { db }: { db: GenericDatabaseReader<DataModel> },
       args: RateLimitArgsWithoutConfig<Name> &
-        (Name extends RateLimitNames ? {} : { config: RateLimitConfig }),
+        (Name extends RateLimitNames ? object : { config: RateLimitConfig }),
     ) => {
       const config = ("config" in args && args.config) || limits[args.name];
       if (!config) {
@@ -281,7 +280,7 @@ export function defineRateLimits<
     rateLimit: async <Name extends string = RateLimitNames>(
       ctx: { db: GenericDatabaseWriter<RateLimitDataModel> },
       args: RateLimitArgsWithoutConfig<Name> &
-        (Name extends RateLimitNames ? {} : { config: RateLimitConfig }),
+        (Name extends RateLimitNames ? object : { config: RateLimitConfig }),
     ) => {
       const config = ("config" in args && args.config) || limits[args.name];
       if (!config) {
diff --git a/packages/convex-helpers/server/retries.ts b/packages/convex-helpers/server/retries.ts
@@ -162,7 +162,7 @@ export function makeActionRetrier(
           });
           break;
 
-        case "failed":
+        case "failed": {
           if (args.maxFailures <= 0) {
             log(
               `Job ${args.action}(${job}) failed too many times, not retrying.`,
@@ -189,6 +189,7 @@ export function makeActionRetrier(
             },
           );
           break;
+        }
 
         case "success":
           log(`Job ${args.action}(${job}) succeeded.`);
diff --git a/packages/convex-helpers/server/rowLevelSecurity.test.ts b/packages/convex-helpers/server/rowLevelSecurity.test.ts
@@ -111,7 +111,7 @@ const mutationWithRLS = customMutation(
 
 customMutation(
   mutationWithRLS,
-  customCtx((ctx) => ({ foo: "bar" })),
+  customCtx((_ctx) => ({ foo: "bar" })),
 ) satisfies typeof mutation;
 
 crud(schema, "users", queryGeneric, mutationWithRLS);
diff --git a/packages/convex-helpers/server/stream.test.ts b/packages/convex-helpers/server/stream.test.ts
@@ -618,7 +618,6 @@ describe("stream", () => {
         .query("foo")
         .withIndex("abc", (q) => q.eq("a", 1))
         .filterWith(async () => false)
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         .flatMap(async () => null as any, ["a", "b", "c"])
         .collect();
       expect(result).toEqual([]);
diff --git a/packages/convex-helpers/server/triggers.test.ts b/packages/convex-helpers/server/triggers.test.ts
@@ -32,7 +32,7 @@ triggers.register("users", async (ctx, change) => {
   if (change.newDoc) {
     const fullName = `${change.newDoc.firstName} ${change.newDoc.lastName}`;
     if (change.newDoc.fullName !== fullName) {
-      ctx.db.patch(change.id, { fullName });
+      await ctx.db.patch(change.id, { fullName });
     }
   }
 });
diff --git a/packages/convex-helpers/server/triggers.ts b/packages/convex-helpers/server/triggers.ts
@@ -145,8 +145,8 @@ class Lock {
  *   To avoid such problems, triggers should be resilient to such
  *   inconsistencies or the trigger graph should be kept simple.
  */
-let innerWriteLock = new Lock();
-let outerWriteLock = new Lock();
+const innerWriteLock = new Lock();
+const outerWriteLock = new Lock();
 const triggerQueue: (() => Promise<void>)[] = [];
 
 export class DatabaseWriterWithTriggers<
diff --git a/packages/convex-helpers/server/validators.test.ts b/packages/convex-helpers/server/validators.test.ts
@@ -32,7 +32,7 @@ import { modules } from "./setup.test.js";
 import { getOrThrow } from "convex-helpers/server/relationships";
 import { validate } from "../validators.js";
 import { fail } from "assert";
-import type { Expand } from "convex-helpers";
+import { type Expand } from "convex-helpers";
 
 export const testLiterals = internalQueryGeneric({
   args: {
diff --git a/packages/convex-helpers/server/zod.test.ts b/packages/convex-helpers/server/zod.test.ts
@@ -792,15 +792,15 @@ expectTypeOf(
 ).toEqualTypeOf({
   branded2: v.string() as VString<string & z.BRAND<"branded2">>,
 });
-const s = zBrand(z.string(), "brand");
-const n = zBrand(z.number(), "brand");
-const i = zBrand(z.bigint(), "brand");
-expectTypeOf<z.input<typeof s>>().toEqualTypeOf<string & z.BRAND<"brand">>();
-expectTypeOf<z.output<typeof s>>().toEqualTypeOf<string & z.BRAND<"brand">>();
-expectTypeOf<z.input<typeof n>>().toEqualTypeOf<number & z.BRAND<"brand">>();
-expectTypeOf<z.output<typeof n>>().toEqualTypeOf<number & z.BRAND<"brand">>();
-expectTypeOf<z.input<typeof i>>().toEqualTypeOf<bigint & z.BRAND<"brand">>();
-expectTypeOf<z.output<typeof i>>().toEqualTypeOf<bigint & z.BRAND<"brand">>();
+const _s = zBrand(z.string(), "brand");
+const _n = zBrand(z.number(), "brand");
+const _i = zBrand(z.bigint(), "brand");
+expectTypeOf<z.input<typeof _s>>().toEqualTypeOf<string & z.BRAND<"brand">>();
+expectTypeOf<z.output<typeof _s>>().toEqualTypeOf<string & z.BRAND<"brand">>();
+expectTypeOf<z.input<typeof _n>>().toEqualTypeOf<number & z.BRAND<"brand">>();
+expectTypeOf<z.output<typeof _n>>().toEqualTypeOf<number & z.BRAND<"brand">>();
+expectTypeOf<z.input<typeof _i>>().toEqualTypeOf<bigint & z.BRAND<"brand">>();
+expectTypeOf<z.output<typeof _i>>().toEqualTypeOf<bigint & z.BRAND<"brand">>();
 
 function sameType<T, U>(_t: T, _u: U): Equals<T, U> {
   return true as any;
diff --git a/packages/convex-helpers/server/zod.ts b/packages/convex-helpers/server/zod.ts
diff --git a/src/components/HonoExample.tsx b/src/components/HonoExample.tsx
diff --git a/src/components/SessionsExample.tsx b/src/components/SessionsExample.tsx
diff --git a/src/fakeConvexClient/fakeConvexClient.d.ts b/src/fakeConvexClient/fakeConvexClient.d.ts
diff --git a/src/hooks/useSingleFlight.ts b/src/hooks/useSingleFlight.ts
diff --git a/tsconfig.json b/tsconfig.json

Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ export const openApiSpec = new Command("open-api-spec")`
`35`	`35`	`).default(undefined),`
`36`	`36`	`)`
`37`	`37`	`.action(async (options) => {`
`38`		`- let content = getFunctionSpec(options.prod, options.inputFile);`
	`38`	`+ const content = getFunctionSpec(options.prod, options.inputFile);`
`39`	`39`	`const outputPath =`
`40`	`40`	(options.outputFile ?? `convex-spec-${Date.now().valueOf()}`) + ".yaml";
`41`	`41`
Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,7 @@ export const tsApiSpec = new Command("ts-api-spec")`
`37`	`37`	`).default(false),`
`38`	`38`	`)`
`39`	`39`	`.action(async (options) => {`
`40`		`- let content = getFunctionSpec(options.prod, options.inputFile);`
	`40`	`+ const content = getFunctionSpec(options.prod, options.inputFile);`
`41`	`41`	`const outputPath =`
`42`	`42`	(options.outputFile ?? `convexApi${Date.now().valueOf()}`) + ".ts";
`43`	`43`