@convex-dev/crons 0.1.9 → 0.2.0

package/dist/{commonjs/component → component}/schema.d.ts

@@ -3,8 +3,8 @@ declare const _default: import("convex/server").SchemaDefinition<{
         name?: string | undefined;
         schedulerJobId?: import("convex/values").GenericId<"_scheduled_functions"> | undefined;
         executionJobId?: import("convex/values").GenericId<"_scheduled_functions"> | undefined;
-        functionHandle: string;
         args: Record<string, any>;
+        functionHandle: string;
         schedule: {
             kind: "interval";
             ms: number;
@@ -41,7 +41,7 @@ declare const _default: import("convex/server").SchemaDefinition<{
         }, "required", "kind" | "cronspec" | "tz">], "required", "kind" | "ms" | "cronspec" | "tz">;
         schedulerJobId: import("convex/values").VId<import("convex/values").GenericId<"_scheduled_functions"> | undefined, "optional">;
         executionJobId: import("convex/values").VId<import("convex/values").GenericId<"_scheduled_functions"> | undefined, "optional">;
-    }, "required", "name" | "functionHandle" | "args" | "schedule" | "schedulerJobId" | "executionJobId" | `args.${string}` | "schedule.kind" | "schedule.ms" | "schedule.cronspec" | "schedule.tz">, {
+    }, "required", "args" | "functionHandle" | "name" | "schedule" | "schedulerJobId" | "executionJobId" | `args.${string}` | "schedule.kind" | "schedule.ms" | "schedule.cronspec" | "schedule.tz">, {
         name: ["name", "_creationTime"];
     }, {}, {}>;
 }, true>;

package/dist/component/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/component/schema.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,wBAoBG"}

package/dist/{commonjs/component → component}/schema.js

@@ -3,7 +3,7 @@ import { v } from "convex/values";
 export default defineSchema({
     // User space crons.
     crons: defineTable({
-        name: v.optional(v.string()),
+        name: v.optional(v.string()), // optional
         functionHandle: v.string(),
         args: v.record(v.string(), v.any()),
         schedule: v.union(v.object({
@@ -11,10 +11,10 @@ export default defineSchema({
             ms: v.float64(), // milliseconds
         }), v.object({
             kind: v.literal("cron"),
-            cronspec: v.string(),
+            cronspec: v.string(), // "* * * * *"
             tz: v.optional(v.string()), // optional timezone, e.g. "America/New_York"
         })),
-        schedulerJobId: v.optional(v.id("_scheduled_functions")),
+        schedulerJobId: v.optional(v.id("_scheduled_functions")), // job to wait for the next execution
         executionJobId: v.optional(v.id("_scheduled_functions")), // async job to run the function
     }).index("name", ["name"]),
 });

package/dist/component/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../src/component/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC1D,OAAO,EAAE,CAAC,EAAE,MAAM,eAAe,CAAC;AAElC,eAAe,YAAY,CAAC;IAC1B,oBAAoB;IACpB,KAAK,EAAE,WAAW,CAAC;QACjB,IAAI,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,WAAW;QACzC,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE;QAC1B,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,GAAG,EAAE,CAAC;QACnC,QAAQ,EAAE,CAAC,CAAC,KAAK,CACf,CAAC,CAAC,MAAM,CAAC;YACP,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC;YAC3B,EAAE,EAAE,CAAC,CAAC,OAAO,EAAE,EAAE,eAAe;SACjC,CAAC,EACF,CAAC,CAAC,MAAM,CAAC;YACP,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC;YACvB,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,EAAE,cAAc;YACpC,EAAE,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,6CAA6C;SAC1E,CAAC,CACH;QACD,cAAc,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,sBAAsB,CAAC,CAAC,EAAE,qCAAqC;QAC/F,cAAc,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,sBAAsB,CAAC,CAAC,EAAE,gCAAgC;KAC3F,CAAC,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,MAAM,CAAC,CAAC;CAC3B,CAAC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@convex-dev/crons",
-  "version": "0.1.9",
+  "version": "0.2.0",
   "description": "Convex component for scheduling periodic jobs.",
   "keywords": [
     "convex",
@@ -17,56 +17,75 @@
   "repository": "github:get-convex/crons",
   "license": "Apache-2.0",
   "type": "module",
-  "exports": {
-    "./package.json": "./package.json",
-    ".": {
-      "import": {
-        "@convex-dev/component-source": "./src/client/index.ts",
-        "types": "./dist/esm/client/index.d.ts",
-        "default": "./dist/esm/client/index.js"
-      },
-      "require": {
-        "@convex-dev/component-source": "./src/client/index.ts",
-        "types": "./dist/commonjs/client/index.d.ts",
-        "default": "./dist/commonjs/client/index.js"
-      }
-    },
-    "./convex.config": {
-      "import": {
-        "@convex-dev/component-source": "./src/component/convex.config.ts",
-        "types": "./dist/esm/component/convex.config.d.ts",
-        "default": "./dist/esm/component/convex.config.js"
-      }
-    }
-  },
-  "main": "./dist/commonjs/client/index.js",
-  "module": "./dist/esm/client/index.js",
-  "types": "./dist/commonjs/client/index.d.ts",
   "files": [
     "dist",
     "src"
   ],
   "scripts": {
-    "build": "npm run build:esm && npm run build:cjs",
-    "build:cjs": "tsc --project ./commonjs.json && echo '{\\n  \"type\": \"commonjs\"\\n}' > dist/commonjs/package.json",
-    "build:esm": "tsc --project ./esm.json && echo '{\\n  \"type\": \"module\"\\n}' > dist/esm/package.json",
-    "lint": "eslint --ext .ts src",
+    "dev": "run-p -r 'dev:*'",
+    "dev:backend": "convex dev --typecheck-components",
+    "dev:frontend": "cd example && vite --clearScreen false",
+    "dev:build": "chokidar 'tsconfig*.json' 'src/**/*.ts' -i '**/*.test.ts' -c 'convex codegen --component-dir ./src/component && npm run build' --initial",
+    "predev": "npm run dev:backend -- --until-success",
+    "clean": "rm -rf dist *.tsbuildinfo",
+    "build": "tsc --project ./tsconfig.build.json",
+    "typecheck": "tsc --noEmit && tsc -p example/convex",
+    "lint": "eslint .",
+    "all": "run-p -r 'dev:*' 'test:watch'",
+    "test": "vitest run --typecheck",
+    "test:watch": "vitest --typecheck --clearScreen false",
+    "test:debug": "vitest --inspect-brk --no-file-parallelism",
+    "test:coverage": "vitest run --coverage --coverage.reporter=text",
     "prepare": "npm run build",
-    "typecheck": "tsc --noEmit"
+    "alpha": "npm run clean && npm ci && run-p test lint typecheck && npm version prerelease --preid alpha && npm publish --tag alpha && git push --tags",
+    "release": "npm run clean && npm ci && run-p test lint typecheck && npm version patch && npm publish && git push --tags",
+    "version": "pbcopy <<<$npm_package_version; vim CHANGELOG.md && prettier -w CHANGELOG.md && git add CHANGELOG.md"
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/client/index.d.ts",
+      "default": "./dist/client/index.js"
+    },
+    "./test": "./src/test.ts",
+    "./_generated/component.js": {
+      "types": "./dist/component/_generated/component.d.ts"
+    },
+    "./convex.config": {
+      "types": "./dist/component/convex.config.d.ts",
+      "default": "./dist/component/convex.config.js"
+    },
+    "./convex.config.js": {
+      "types": "./dist/component/convex.config.d.ts",
+      "default": "./dist/component/convex.config.js"
+    }
   },
+  "module": "./dist/client/index.js",
+  "types": "./dist/client/index.d.ts",
   "dependencies": {
     "cron-parser": "^4.9.0"
   },
+  "peerDependencies": {
+    "convex": "^1.24.8"
+  },
   "devDependencies": {
+    "@arethetypeswrong/cli": "0.18.2",
+    "@edge-runtime/vm": "5.0.0",
+    "@eslint/eslintrc": "^3.1.0",
     "@eslint/js": "^9.28.0",
-    "@types/node": "^18.17.0",
+    "@types/node": "20.19.24",
+    "@typescript-eslint/eslint-plugin": "^8.4.0",
+    "@typescript-eslint/parser": "^8.4.0",
+    "chokidar-cli": "3.0.0",
+    "convex-test": "^0.0.38",
     "eslint": "^9.28.0",
+    "eslint-plugin-react-hooks": "^7.0.1",
+    "eslint-plugin-react-refresh": "^0.4.24",
     "globals": "^16.2.0",
+    "npm-run-all2": "8.0.4",
     "prettier": "3.2.5",
-    "typescript": "~5.0.3",
-    "typescript-eslint": "^8.33.1"
-  },
-  "peerDependencies": {
-    "convex": "~1.16.5 || >=1.17.0 <1.35.0"
+    "typescript": "^5.5.0",
+    "typescript-eslint": "^8.33.1",
+    "vitest": "^3.2.4"
   }
 }

package/src/client/index.ts

@@ -2,13 +2,13 @@
 
 import {
   createFunctionHandle,
-  FunctionArgs,
-  FunctionHandle,
-  SchedulableFunctionReference,
+  type FunctionArgs,
+  type FunctionHandle,
+  type SchedulableFunctionReference,
 } from "convex/server";
-import { api } from "../component/_generated/api.js";
-import { CronInfo, Schedule } from "../component/public.js";
-import { RunMutationCtx, RunQueryCtx, UseApi } from "./utils.js";
+import type { ComponentApi } from "../component/_generated/component.js";
+import type { CronInfo, Schedule } from "../component/public.js";
+import type { RunMutationCtx, RunQueryCtx } from "./utils.js";
 
 export type { CronInfo };
 
@@ -52,7 +52,7 @@ export class Crons {
    * }
    * ```
    */
-  constructor(private component: UseApi<typeof api>) {}
+  constructor(private component: ComponentApi) {}
 
   /**
    * Schedule a mutation or action to run on a cron schedule or interval.
@@ -71,7 +71,7 @@ export class Crons {
     schedule: Schedule,
     func: F,
     args: FunctionArgs<F>,
-    name?: string
+    name?: string,
   ): Promise<string> {
     return ctx.runMutation(this.component.public.register, {
       name,
@@ -104,7 +104,7 @@ export class Crons {
    */
   async get(
     ctx: RunQueryCtx,
-    identifier: { id: string } | { name: string }
+    identifier: { id: string } | { name: string },
   ): Promise<CronInfo | null> {
     const cron = await ctx.runQuery(this.component.public.get, { identifier });
     if (cron === null) {
@@ -125,7 +125,7 @@ export class Crons {
    */
   async delete(
     ctx: RunMutationCtx,
-    identifier: { id: string } | { name: string }
+    identifier: { id: string } | { name: string },
   ): Promise<null> {
     return ctx.runMutation(this.component.public.del, { identifier });
   }

package/src/client/utils.ts

@@ -1,13 +1,8 @@
-// Type utilities for component clients.
-
 import type {
-  Expand,
-  FunctionReference,
   GenericDataModel,
   GenericMutationCtx,
   GenericQueryCtx,
 } from "convex/server";
-import type { GenericId } from "convex/values";
 
 export type RunQueryCtx = {
   runQuery: GenericQueryCtx<GenericDataModel>["runQuery"];
@@ -15,30 +10,3 @@ export type RunQueryCtx = {
 export type RunMutationCtx = {
   runMutation: GenericMutationCtx<GenericDataModel>["runMutation"];
 };
-
-export type OpaqueIds<T> =
-  T extends GenericId<infer _T>
-    ? string
-    : T extends (infer U)[]
-      ? OpaqueIds<U>[]
-      : T extends object
-        ? { [K in keyof T]: OpaqueIds<T[K]> }
-        : T;
-
-export type UseApi<API> = Expand<{
-  [mod in keyof API]: API[mod] extends FunctionReference<
-    infer FType,
-    "public",
-    infer FArgs,
-    infer FReturnType,
-    infer FComponentPath
-  >
-    ? FunctionReference<
-        FType,
-        "internal",
-        OpaqueIds<FArgs>,
-        OpaqueIds<FReturnType>,
-        FComponentPath
-      >
-    : UseApi<API[mod]>;
-}>;

package/src/component/_generated/api.ts

@@ -0,0 +1,50 @@
+/* eslint-disable */
+/**
+ * Generated `api` utility.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+
+import type * as public_ from "../public.js";
+
+import type {
+  ApiFromModules,
+  FilterApi,
+  FunctionReference,
+} from "convex/server";
+import { anyApi, componentsGeneric } from "convex/server";
+
+const fullApi: ApiFromModules<{
+  public: typeof public_;
+}> = anyApi as any;
+
+/**
+ * A utility for referencing Convex functions in your app's public API.
+ *
+ * Usage:
+ * ```js
+ * const myFunctionReference = api.myModule.myFunction;
+ * ```
+ */
+export const api: FilterApi<
+  typeof fullApi,
+  FunctionReference<any, "public">
+> = anyApi as any;
+
+/**
+ * A utility for referencing Convex functions in your app's internal API.
+ *
+ * Usage:
+ * ```js
+ * const myFunctionReference = internal.myModule.myFunction;
+ * ```
+ */
+export const internal: FilterApi<
+  typeof fullApi,
+  FunctionReference<any, "internal">
+> = anyApi as any;
+
+export const components = componentsGeneric() as unknown as {};

package/src/component/_generated/component.ts

@@ -0,0 +1,79 @@
+/* eslint-disable */
+/**
+ * Generated `ComponentApi` utility.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+
+import type { FunctionReference } from "convex/server";
+
+/**
+ * A utility for referencing a Convex component's exposed API.
+ *
+ * Useful when expecting a parameter like `components.myComponent`.
+ * Usage:
+ * ```ts
+ * async function myFunction(ctx: QueryCtx, component: ComponentApi) {
+ *   return ctx.runQuery(component.someFile.someQuery, { ...args });
+ * }
+ * ```
+ */
+export type ComponentApi<Name extends string | undefined = string | undefined> =
+  {
+    public: {
+      del: FunctionReference<
+        "mutation",
+        "internal",
+        { identifier: { id: string } | { name: string } },
+        null,
+        Name
+      >;
+      get: FunctionReference<
+        "query",
+        "internal",
+        { identifier: { id: string } | { name: string } },
+        {
+          args: Record<string, any>;
+          functionHandle: string;
+          id: string;
+          name?: string;
+          schedule:
+            | { kind: "interval"; ms: number }
+            | { cronspec: string; kind: "cron"; tz?: string };
+        } | null,
+        Name
+      >;
+      list: FunctionReference<
+        "query",
+        "internal",
+        {},
+        Array<{
+          args: Record<string, any>;
+          functionHandle: string;
+          id: string;
+          name?: string;
+          schedule:
+            | { kind: "interval"; ms: number }
+            | { cronspec: string; kind: "cron"; tz?: string };
+        }>,
+        Name
+      >;
+      register: FunctionReference<
+        "mutation",
+        "internal",
+        {
+          args: Record<string, any>;
+          functionHandle: string;
+          name?: string;
+          schedule:
+            | { kind: "interval"; ms: number }
+            | { cronspec: string; kind: "cron"; tz?: string };
+        },
+        string,
+        Name
+      >;
+    };
+  };

package/src/component/_generated/{dataModel.d.ts → dataModel.ts}

@@ -1,5 +1,3 @@
-/* prettier-ignore-start */
-
 /* eslint-disable */
 /**
  * Generated data model types.
@@ -60,5 +58,3 @@ export type Id<TableName extends TableNames | SystemTableNames> =
  * `mutationGeneric` to make them type-safe.
  */
 export type DataModel = DataModelFromSchemaDefinition<typeof schema>;
-
-/* prettier-ignore-end */

package/src/component/_generated/server.ts

@@ -0,0 +1,161 @@
+/* eslint-disable */
+/**
+ * Generated utilities for implementing server-side Convex query and mutation functions.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+
+import type {
+  ActionBuilder,
+  HttpActionBuilder,
+  MutationBuilder,
+  QueryBuilder,
+  GenericActionCtx,
+  GenericMutationCtx,
+  GenericQueryCtx,
+  GenericDatabaseReader,
+  GenericDatabaseWriter,
+} from "convex/server";
+import {
+  actionGeneric,
+  httpActionGeneric,
+  queryGeneric,
+  mutationGeneric,
+  internalActionGeneric,
+  internalMutationGeneric,
+  internalQueryGeneric,
+} from "convex/server";
+import type { DataModel } from "./dataModel.js";
+
+/**
+ * Define a query in this Convex app's public API.
+ *
+ * This function will be allowed to read your Convex database and will be accessible from the client.
+ *
+ * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
+ * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
+ */
+export const query: QueryBuilder<DataModel, "public"> = queryGeneric;
+
+/**
+ * Define a query that is only accessible from other Convex functions (but not from the client).
+ *
+ * This function will be allowed to read from your Convex database. It will not be accessible from the client.
+ *
+ * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
+ * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
+ */
+export const internalQuery: QueryBuilder<DataModel, "internal"> =
+  internalQueryGeneric;
+
+/**
+ * Define a mutation in this Convex app's public API.
+ *
+ * This function will be allowed to modify your Convex database and will be accessible from the client.
+ *
+ * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
+ * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
+ */
+export const mutation: MutationBuilder<DataModel, "public"> = mutationGeneric;
+
+/**
+ * Define a mutation that is only accessible from other Convex functions (but not from the client).
+ *
+ * This function will be allowed to modify your Convex database. It will not be accessible from the client.
+ *
+ * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
+ * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
+ */
+export const internalMutation: MutationBuilder<DataModel, "internal"> =
+  internalMutationGeneric;
+
+/**
+ * Define an action in this Convex app's public API.
+ *
+ * An action is a function which can execute any JavaScript code, including non-deterministic
+ * code and code with side-effects, like calling third-party services.
+ * They can be run in Convex's JavaScript environment or in Node.js using the "use node" directive.
+ * They can interact with the database indirectly by calling queries and mutations using the {@link ActionCtx}.
+ *
+ * @param func - The action. It receives an {@link ActionCtx} as its first argument.
+ * @returns The wrapped action. Include this as an `export` to name it and make it accessible.
+ */
+export const action: ActionBuilder<DataModel, "public"> = actionGeneric;
+
+/**
+ * Define an action that is only accessible from other Convex functions (but not from the client).
+ *
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument.
+ * @returns The wrapped function. Include this as an `export` to name it and make it accessible.
+ */
+export const internalAction: ActionBuilder<DataModel, "internal"> =
+  internalActionGeneric;
+
+/**
+ * Define an HTTP action.
+ *
+ * The wrapped function will be used to respond to HTTP requests received
+ * by a Convex deployment if the requests matches the path and method where
+ * this action is routed. Be sure to route your httpAction in `convex/http.js`.
+ *
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument
+ * and a Fetch API `Request` object as its second.
+ * @returns The wrapped function. Import this function from `convex/http.js` and route it to hook it up.
+ */
+export const httpAction: HttpActionBuilder = httpActionGeneric;
+
+type GenericCtx =
+  | GenericActionCtx<DataModel>
+  | GenericMutationCtx<DataModel>
+  | GenericQueryCtx<DataModel>;
+
+/**
+ * A set of services for use within Convex query functions.
+ *
+ * The query context is passed as the first argument to any Convex query
+ * function run on the server.
+ *
+ * If you're using code generation, use the `QueryCtx` type in `convex/_generated/server.d.ts` instead.
+ */
+export type QueryCtx = GenericQueryCtx<DataModel>;
+
+/**
+ * A set of services for use within Convex mutation functions.
+ *
+ * The mutation context is passed as the first argument to any Convex mutation
+ * function run on the server.
+ *
+ * If you're using code generation, use the `MutationCtx` type in `convex/_generated/server.d.ts` instead.
+ */
+export type MutationCtx = GenericMutationCtx<DataModel>;
+
+/**
+ * A set of services for use within Convex action functions.
+ *
+ * The action context is passed as the first argument to any Convex action
+ * function run on the server.
+ */
+export type ActionCtx = GenericActionCtx<DataModel>;
+
+/**
+ * An interface to read from the database within Convex query functions.
+ *
+ * The two entry points are {@link DatabaseReader.get}, which fetches a single
+ * document by its {@link Id}, or {@link DatabaseReader.query}, which starts
+ * building a query.
+ */
+export type DatabaseReader = GenericDatabaseReader<DataModel>;
+
+/**
+ * An interface to read from and write to the database within Convex mutation
+ * functions.
+ *
+ * Convex guarantees that all writes within a single mutation are
+ * executed atomically, so you never have to worry about partial writes leaving
+ * your data in an inconsistent state. See [the Convex Guide](https://docs.convex.dev/understanding/convex-fundamentals/functions#atomicity-and-optimistic-concurrency-control)
+ * for the guarantees Convex provides your functions.
+ */
+export type DatabaseWriter = GenericDatabaseWriter<DataModel>;

package/src/component/public.ts

@@ -2,16 +2,16 @@
 //
 // See ../client/index.ts for the public API.
 
-import { FunctionHandle } from "convex/server";
+import type { FunctionHandle } from "convex/server";
 import { v } from "convex/values";
 import {
-  MutationCtx,
+  type MutationCtx,
   mutation,
   query,
   internalMutation,
 } from "./_generated/server.js";
 import { internal } from "./_generated/api.js";
-import { Doc, Id } from "./_generated/dataModel.js";
+import type { Doc, Id } from "./_generated/dataModel.js";
 import parser from "cron-parser";
 import schema from "./schema.js";
 
@@ -99,7 +99,7 @@ export const register = mutation({
       schedule,
     });
     console.log(
-      `Scheduling cron "${name}" (${id}) on schedule ${JSON.stringify(schedule)}`
+      `Scheduling cron "${name}" (${id}) on schedule ${JSON.stringify(schedule)}`,
     );
 
     await scheduleNextRun(ctx, id, new Date(), schedule);
@@ -124,13 +124,13 @@ async function scheduleNextRun(
   ctx: MutationCtx,
   id: Id<"crons">,
   lastScheduled: Date,
-  schedule: Schedule
+  schedule: Schedule,
 ) {
   const nextRun = calculateNextRun(lastScheduled, schedule);
   const schedulerJobId = await ctx.scheduler.runAt(
     nextRun,
     internal.public.rescheduler,
-    { id }
+    { id },
   );
   await ctx.db.patch(id, { schedulerJobId });
 }
@@ -177,7 +177,7 @@ export const get = query({
   args: {
     identifier: v.union(
       v.object({ id: v.id("crons") }),
-      v.object({ name: v.string() })
+      v.object({ name: v.string() }),
     ),
   },
   returns: v.union(cronInfoValidator, v.null()),
@@ -209,7 +209,7 @@ export const del = mutation({
   args: {
     identifier: v.union(
       v.object({ id: v.id("crons") }),
-      v.object({ name: v.string() })
+      v.object({ name: v.string() }),
     ),
   },
   returns: v.null(),
@@ -276,7 +276,7 @@ export const rescheduler = internalMutation({
       schedulerJob.state.kind !== "inProgress"
     ) {
       throw Error(
-        `We are running in job ${schedulerJob._id} but state is ${schedulerJob.state.kind}`
+        `We are running in job ${schedulerJob._id} but state is ${schedulerJob.state.kind}`,
       );
     }
 
@@ -299,7 +299,7 @@ export const rescheduler = internalMutation({
       await ctx.scheduler.runAfter(
         0,
         cronJob.functionHandle as FunctionHandle<"mutation" | "action">,
-        cronJob.args
+        cronJob.args,
       );
     }
 
@@ -307,7 +307,7 @@ export const rescheduler = internalMutation({
       ctx,
       id,
       new Date(schedulerJob.scheduledTime),
-      cronJob.schedule
+      cronJob.schedule,
     );
   },
 });

package/src/component/schema.ts

@@ -16,7 +16,7 @@ export default defineSchema({
         kind: v.literal("cron"),
         cronspec: v.string(), // "* * * * *"
         tz: v.optional(v.string()), // optional timezone, e.g. "America/New_York"
-      })
+      }),
     ),
     schedulerJobId: v.optional(v.id("_scheduled_functions")), // job to wait for the next execution
     executionJobId: v.optional(v.id("_scheduled_functions")), // async job to run the function