@sentry/junior-scheduler 0.75.0 → 0.76.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 export { createSchedulerPlugin, schedulerPlugin } from "./plugin";
 export { createSlackScheduleCreateTaskTool, createSlackScheduleDeleteTaskTool, createSlackScheduleListTasksTool, createSlackScheduleRunTaskNowTool, createSlackScheduleUpdateTaskTool, type SchedulerToolContext, } from "./schedule-tools";
-export { createSchedulerOperationalSqlStore, createSchedulerSqlStore, migrateSchedulerStateToSql, } from "./store";
+export { createSchedulerOperationalSqlStore, createSchedulerSqlStore, migrateSchedulerStateToSql, type SchedulerDb, } from "./store";
 export type { ScheduledCalendarFrequency, ScheduledLocalTime, ScheduledRun, ScheduledRunStatus, ScheduledTask, ScheduledTaskConversationAccess, ScheduledTaskExecutionActor, ScheduledTaskPrincipal, ScheduledTaskRecurrence, ScheduledTaskSchedule, ScheduledTaskSpec, ScheduledTaskStatus, } from "./types";

package/dist/index.js

@@ -1,5 +1,6 @@
 // src/plugin.ts
 import {
+  createSlackSource,
   defineJuniorPlugin
 } from "@sentry/junior-plugin-api";
 
@@ -9,6 +10,17 @@ import {
   destinationSchema,
   isSlackDestination
 } from "@sentry/junior-plugin-api";
+import {
+  and,
+  asc,
+  eq,
+  inArray,
+  isNotNull,
+  lte,
+  ne,
+  or,
+  sql as sql2
+} from "drizzle-orm";
 import { z } from "zod";
 
 // src/cadence.ts
@@ -97,7 +109,7 @@ function localDateTimeToTimestampMs(args) {
     0
   );
   let timestampMs = localAsUtcMs - getTimeZoneOffsetMs(localAsUtcMs, args.timezone);
-  for (let index = 0; index < 3; index += 1) {
+  for (let index2 = 0; index2 < 3; index2 += 1) {
     const next = localAsUtcMs - getTimeZoneOffsetMs(timestampMs, args.timezone);
     if (next === timestampMs) {
       break;
@@ -358,6 +370,52 @@ function getNextRunAtMs(task, scheduledForMs, afterMs = scheduledForMs) {
   });
 }
 
+// src/db/schema.ts
+import { sql } from "drizzle-orm";
+import { bigint, index, jsonb, pgTable, text } from "drizzle-orm/pg-core";
+var juniorSchedulerTasks = pgTable(
+  "junior_scheduler_tasks",
+  {
+    id: text("id").primaryKey(),
+    teamId: text("team_id").notNull(),
+    status: text("status").notNull(),
+    nextRunAtMs: bigint("next_run_at_ms", { mode: "number" }),
+    runNowAtMs: bigint("run_now_at_ms", { mode: "number" }),
+    createdAtMs: bigint("created_at_ms", { mode: "number" }).notNull(),
+    record: jsonb("record").$type().notNull()
+  },
+  (table) => [
+    index("junior_scheduler_tasks_team_status_idx").on(table.teamId, table.createdAtMs, table.id).where(sql`${table.status} <> 'deleted'`),
+    index("junior_scheduler_tasks_run_now_due_idx").on(table.runNowAtMs, table.createdAtMs, table.id).where(
+      sql`${table.status} = 'active' AND ${table.runNowAtMs} IS NOT NULL`
+    ),
+    index("junior_scheduler_tasks_next_run_due_idx").on(table.nextRunAtMs, table.createdAtMs, table.id).where(
+      sql`${table.status} = 'active' AND ${table.nextRunAtMs} IS NOT NULL`
+    )
+  ]
+);
+var juniorSchedulerRuns = pgTable(
+  "junior_scheduler_runs",
+  {
+    id: text("id").primaryKey(),
+    taskId: text("task_id").notNull(),
+    status: text("status").notNull(),
+    scheduledForMs: bigint("scheduled_for_ms", { mode: "number" }).notNull(),
+    record: jsonb("record").$type().notNull()
+  },
+  (table) => [
+    index("junior_scheduler_runs_task_status_idx").on(
+      table.taskId,
+      table.status,
+      table.scheduledForMs
+    ),
+    index("junior_scheduler_runs_status_idx").on(
+      table.status,
+      table.scheduledForMs
+    )
+  ]
+);
+
 // src/store.ts
 var SCHEDULER_KEY_PREFIX = "junior:scheduler";
 var SCHEDULER_RECORD_TTL_MS = 5 * 365 * 24 * 60 * 60 * 1e3;
@@ -616,111 +674,74 @@ function parseSqlRunRow(row) {
   const parsed = runRecordSchema.safeParse(parseJsonRecord(row.record));
   return parsed.success ? stripLegacyRunFields(parsed.data) : void 0;
 }
-function json(value) {
-  return JSON.stringify(value);
-}
 async function withSqlLock(db, key, callback) {
   return await db.transaction(async (tx) => {
-    await tx.execute("SELECT pg_advisory_xact_lock(hashtext($1))", [key]);
+    await tx.execute(sql2`SELECT pg_advisory_xact_lock(hashtext(${key}))`);
     return await callback(tx);
   });
 }
 async function upsertSqlTask(db, task) {
-  await db.execute(
-    `
-INSERT INTO junior_scheduler_tasks (
-  id,
-  team_id,
-  status,
-  next_run_at_ms,
-  run_now_at_ms,
-  created_at_ms,
-  record
-) VALUES (
-  $1, $2, $3, $4, $5, $6, $7::jsonb
-)
-ON CONFLICT (id) DO UPDATE SET
-  team_id = EXCLUDED.team_id,
-  status = EXCLUDED.status,
-  next_run_at_ms = EXCLUDED.next_run_at_ms,
-  run_now_at_ms = EXCLUDED.run_now_at_ms,
-  created_at_ms = EXCLUDED.created_at_ms,
-  record = EXCLUDED.record
-`,
-    [
-      task.id,
-      task.destination.teamId,
-      task.status,
-      task.nextRunAtMs ?? null,
-      task.runNowAtMs ?? null,
-      task.createdAtMs,
-      json(task)
-    ]
-  );
+  await db.insert(juniorSchedulerTasks).values({
+    createdAtMs: task.createdAtMs,
+    id: task.id,
+    nextRunAtMs: task.nextRunAtMs,
+    record: task,
+    runNowAtMs: task.runNowAtMs,
+    status: task.status,
+    teamId: task.destination.teamId
+  }).onConflictDoUpdate({
+    target: juniorSchedulerTasks.id,
+    set: {
+      createdAtMs: sql2`excluded.created_at_ms`,
+      nextRunAtMs: sql2`excluded.next_run_at_ms`,
+      record: sql2`excluded.record`,
+      runNowAtMs: sql2`excluded.run_now_at_ms`,
+      status: sql2`excluded.status`,
+      teamId: sql2`excluded.team_id`
+    }
+  });
 }
 async function upsertSqlRun(db, run) {
-  await db.execute(
-    `
-INSERT INTO junior_scheduler_runs (
-  id,
-  task_id,
-  status,
-  scheduled_for_ms,
-  record
-) VALUES (
-  $1, $2, $3, $4, $5::jsonb
-)
-ON CONFLICT (id) DO UPDATE SET
-  task_id = EXCLUDED.task_id,
-  status = EXCLUDED.status,
-  scheduled_for_ms = EXCLUDED.scheduled_for_ms,
-  record = EXCLUDED.record
-`,
-    [run.id, run.taskId, run.status, run.scheduledForMs, json(run)]
-  );
+  await db.insert(juniorSchedulerRuns).values({
+    id: run.id,
+    record: run,
+    scheduledForMs: run.scheduledForMs,
+    status: run.status,
+    taskId: run.taskId
+  }).onConflictDoUpdate({
+    target: juniorSchedulerRuns.id,
+    set: {
+      record: sql2`excluded.record`,
+      scheduledForMs: sql2`excluded.scheduled_for_ms`,
+      status: sql2`excluded.status`,
+      taskId: sql2`excluded.task_id`
+    }
+  });
 }
 async function getTaskFromSql(db, taskId) {
-  const rows = await db.query(
-    "SELECT record FROM junior_scheduler_tasks WHERE id = $1",
-    [taskId]
-  );
+  const rows = await db.select({ record: juniorSchedulerTasks.record }).from(juniorSchedulerTasks).where(eq(juniorSchedulerTasks.id, taskId)).limit(1);
   return rows[0] ? parseSqlTaskRow(rows[0]) : void 0;
 }
 async function getRunFromSql(db, runId) {
-  const rows = await db.query(
-    "SELECT record FROM junior_scheduler_runs WHERE id = $1",
-    [runId]
-  );
-  return rows[0] ? parseSqlRunRow(rows[0]) : void 0;
-}
-async function getClaimedRunSlotFromSql(db, runId) {
-  const rows = await db.query(
-    "SELECT record FROM junior_scheduler_runs WHERE id = $1",
-    [runId]
-  );
+  const rows = await db.select({ record: juniorSchedulerRuns.record }).from(juniorSchedulerRuns).where(eq(juniorSchedulerRuns.id, runId)).limit(1);
   return rows[0] ? parseSqlRunRow(rows[0]) : void 0;
 }
 async function listTasksFromSql(db) {
-  const rows = await db.query(
-    `
-SELECT record
-FROM junior_scheduler_tasks
-WHERE status <> 'deleted'
-ORDER BY created_at_ms ASC, id ASC
-`
+  const rows = await db.select({ record: juniorSchedulerTasks.record }).from(juniorSchedulerTasks).where(ne(juniorSchedulerTasks.status, "deleted")).orderBy(
+    asc(juniorSchedulerTasks.createdAtMs),
+    asc(juniorSchedulerTasks.id)
   );
   return rows.map(parseSqlTaskRow).filter(present);
 }
 async function listTasksForTeamFromSql(db, teamId) {
-  const rows = await db.query(
-    `
-SELECT record
-FROM junior_scheduler_tasks
-WHERE team_id = $1
-  AND status <> 'deleted'
-ORDER BY created_at_ms ASC, id ASC
-`,
-    [teamId]
+  const rows = await db.select({ record: juniorSchedulerTasks.record }).from(juniorSchedulerTasks).where(
+    and(
+      eq(juniorSchedulerTasks.teamId, teamId),
+      ne(juniorSchedulerTasks.status, "deleted")
+    )
+  ).orderBy(
+    asc(juniorSchedulerTasks.createdAtMs),
+    asc(juniorSchedulerTasks.id)
   );
   return rows.map(parseSqlTaskRow).filter(present);
 }
@@ -728,15 +749,17 @@ async function listIncompleteRunsForTasksFromSql(db, tasks) {
   if (tasks.length === 0) {
     return [];
   }
-  const rows = await db.query(
-    `
-SELECT record
-FROM junior_scheduler_runs
-WHERE task_id = ANY($1)
-  AND status = ANY($2)
-ORDER BY scheduled_for_ms ASC, id ASC
-`,
-    [tasks.map((task) => task.id), [...SQL_INCOMPLETE_RUN_STATUSES]]
+  const rows = await db.select({ record: juniorSchedulerRuns.record }).from(juniorSchedulerRuns).where(
+    and(
+      inArray(
+        juniorSchedulerRuns.taskId,
+        tasks.map((task) => task.id)
+      ),
+      inArray(juniorSchedulerRuns.status, [...SQL_INCOMPLETE_RUN_STATUSES])
+    )
+  ).orderBy(
+    asc(juniorSchedulerRuns.scheduledForMs),
+    asc(juniorSchedulerRuns.id)
   );
   return rows.map(parseSqlRunRow).filter(present);
 }
@@ -754,9 +777,11 @@ var SqlSchedulerStore = class {
   }
   async saveTaskRecord(db, task, current) {
     if (current?.status === "blocked" && task.status === "active" && typeof task.nextRunAtMs === "number" && Number.isFinite(task.nextRunAtMs)) {
-      await db.execute(
-        "DELETE FROM junior_scheduler_runs WHERE id = $1 AND status = 'blocked'",
-        [buildRunId(task.id, task.nextRunAtMs)]
+      await db.delete(juniorSchedulerRuns).where(
+        and(
+          eq(juniorSchedulerRuns.id, buildRunId(task.id, task.nextRunAtMs)),
+          eq(juniorSchedulerRuns.status, "blocked")
+        )
       );
     }
     await upsertSqlTask(db, task);
@@ -772,18 +797,23 @@ var SqlSchedulerStore = class {
   }
   async claimDueRun(args) {
     return await withSqlLock(this.db, "junior:scheduler:claim", async (db) => {
-      const rows = await db.query(
-        `
-SELECT record
-FROM junior_scheduler_tasks
-WHERE status = 'active'
-  AND (
-    (run_now_at_ms IS NOT NULL AND run_now_at_ms <= $1)
-    OR (next_run_at_ms IS NOT NULL AND next_run_at_ms <= $1)
-  )
-ORDER BY created_at_ms ASC, id ASC
-`,
-        [args.nowMs]
+      const rows = await db.select({ record: juniorSchedulerTasks.record }).from(juniorSchedulerTasks).where(
+        and(
+          eq(juniorSchedulerTasks.status, "active"),
+          or(
+            and(
+              isNotNull(juniorSchedulerTasks.runNowAtMs),
+              lte(juniorSchedulerTasks.runNowAtMs, args.nowMs)
+            ),
+            and(
+              isNotNull(juniorSchedulerTasks.nextRunAtMs),
+              lte(juniorSchedulerTasks.nextRunAtMs, args.nowMs)
+            )
+          )
+        )
+      ).orderBy(
+        asc(juniorSchedulerTasks.createdAtMs),
+        asc(juniorSchedulerTasks.id)
       );
       for (const row of rows) {
         const task = parseSqlTaskRow(row);
@@ -817,7 +847,7 @@ ORDER BY created_at_ms ASC, id ASC
           await upsertSqlRun(db, reclaimed);
           return reclaimed;
         }
-        const existingRun = await getClaimedRunSlotFromSql(db, runId);
+        const existingRun = await getRunFromSql(db, runId);
         if (existingRun) {
           continue;
         }
@@ -1124,8 +1154,7 @@ import { Type } from "@sinclair/typebox";
 import {
   PluginToolInputError,
   pluginCredentialSubjectSchema as pluginCredentialSubjectSchema2,
-  destinationSchema as destinationSchema2,
-  isSlackDestination as isSlackDestination2
+  sourceSchema
 } from "@sentry/junior-plugin-api";
 
 // src/types.ts
@@ -1142,7 +1171,7 @@ function throwToolInputError(error) {
   throw new PluginToolInputError(error);
 }
 function requireActiveConversation(context) {
-  const parsed = destinationSchema2.safeParse(context.source);
+  const parsed = sourceSchema.safeParse(context.source);
   if (!parsed.success) {
     const source = context.source;
     const issues = parsed.error.issues;
@@ -1162,10 +1191,14 @@ function requireActiveConversation(context) {
     }
     throwToolInputError("No active Slack conversation is available.");
   }
-  if (!isSlackDestination2(parsed.data)) {
+  if (parsed.data.platform !== "slack") {
     throwToolInputError("No active Slack conversation is available.");
   }
-  return parsed.data;
+  return {
+    platform: "slack",
+    teamId: parsed.data.teamId,
+    channelId: parsed.data.channelId
+  };
 }
 function requireRequester(context) {
   if (context.requester?.platform !== "slack") {
@@ -1653,22 +1686,15 @@ function buildScheduledTaskDispatchMetadata(args) {
   };
 }
 function scheduledTaskDispatchSource(task) {
-  return {
-    platform: "slack",
+  return createSlackSource({
     teamId: task.destination.teamId,
     channelId: task.destination.channelId
-  };
+  });
 }
 function schedulerStore2(ctx) {
-  if (!ctx.db) {
-    throw new Error("Scheduler plugin requires ctx.db");
-  }
   return createSchedulerSqlStore(ctx.db);
 }
 function schedulerOperationalStore(ctx) {
-  if (!ctx.db) {
-    throw new Error("Scheduler plugin requires ctx.db");
-  }
   return createSchedulerOperationalSqlStore(ctx.db);
 }
 function shouldSkipRun(task, run) {
@@ -1686,11 +1712,7 @@ function shouldSkipRun(task, run) {
 function createSchedulerToolContext(ctx) {
   return {
     credentialSubject: ctx.slack?.credentialSubject,
-    source: ctx.source.platform === "slack" ? {
-      platform: "slack",
-      teamId: ctx.source.teamId,
-      channelId: ctx.source.channelId
-    } : void 0,
+    source: ctx.source.platform === "slack" ? ctx.source : void 0,
     requester: ctx.requester?.platform === "slack" ? ctx.requester : void 0,
     store: schedulerStore2(ctx),
     userText: ctx.userText
@@ -1937,7 +1959,6 @@ async function buildSchedulerOperationalReport(args) {
 }
 function createSchedulerPlugin() {
   return defineJuniorPlugin({
-    database: {},
     manifest: {
       name: "scheduler",
       displayName: "Scheduler",
@@ -1985,7 +2006,7 @@ function createSchedulerPlugin() {
             processedCount += 1;
           }
         }
-        for (let index = processedCount; index < SCHEDULER_HEARTBEAT_LIMIT; index += 1) {
+        for (let index2 = processedCount; index2 < SCHEDULER_HEARTBEAT_LIMIT; index2 += 1) {
           const run = await store.claimDueRun({ nowMs: ctx.nowMs });
           if (!run) {
             break;
@@ -2062,9 +2083,6 @@ function createSchedulerPlugin() {
         });
       },
       async migrateStorage(ctx) {
-        if (!ctx.db) {
-          throw new Error("Scheduler storage migration requires ctx.db");
-        }
         return await migrateSchedulerStateToSql({
           db: ctx.db,
           state: ctx.state

package/dist/plugin.d.ts

@@ -1,4 +1,4 @@
 /** Create Junior's built-in trusted scheduler plugin. */
 export declare function createSchedulerPlugin(): import("@sentry/junior-plugin-api").PluginRegistration;
-/** Register trusted scheduler runtime hooks for scheduled Junior tasks. */
+/** Register scheduler runtime hooks for scheduled Junior tasks. */
 export declare const schedulerPlugin: typeof createSchedulerPlugin;

package/dist/schedule-tools.d.ts

@@ -1,9 +1,9 @@
-import { type PluginCredentialSubject, type PluginToolDefinition, type SlackDestination, type SlackRequester } from "@sentry/junior-plugin-api";
+import { type PluginCredentialSubject, type PluginToolDefinition, type SlackRequester, type SlackSource } from "@sentry/junior-plugin-api";
 import { type SchedulerStore } from "./store";
 export interface SchedulerToolContext {
     credentialSubject?: PluginCredentialSubject;
     requester?: SlackRequester;
-    source?: SlackDestination;
+    source?: SlackSource;
     store: SchedulerStore;
     userText?: string;
 }

package/dist/store.d.ts

@@ -1,5 +1,9 @@
-import { type PluginDb, type PluginReadState, type PluginState } from "@sentry/junior-plugin-api";
+import { type PluginReadState, type PluginState } from "@sentry/junior-plugin-api";
+import type { PgDatabase } from "drizzle-orm/pg-core";
+import type { PgQueryResultHKT } from "drizzle-orm/pg-core/session";
+import * as schedulerSqlSchema from "./db/schema";
 import type { ScheduledRun, ScheduledTask } from "./types";
+export type SchedulerDb = PgDatabase<PgQueryResultHKT, typeof schedulerSqlSchema>;
 export interface SchedulerStore {
     claimDueRun(args: {
         nowMs: number;
@@ -55,12 +59,12 @@ export declare function createSchedulerStore(state: PluginState): SchedulerStore
 /** Create a read-only scheduler store for operational reporting. */
 export declare function createSchedulerOperationalStore(state: PluginReadState): SchedulerOperationalStore;
 /** Create a scheduler store backed by the plugin SQL database. */
-export declare function createSchedulerSqlStore(db: PluginDb): SchedulerStore;
+export declare function createSchedulerSqlStore(db: SchedulerDb): SchedulerStore;
 /** Create a read-only scheduler operational store backed by SQL. */
-export declare function createSchedulerOperationalSqlStore(db: PluginDb): SchedulerOperationalStore;
+export declare function createSchedulerOperationalSqlStore(db: SchedulerDb): SchedulerOperationalStore;
 /** Copy retained scheduler plugin-state records into the scheduler SQL tables. */
 export declare function migrateSchedulerStateToSql(args: {
-    db: PluginDb;
+    db: SchedulerDb;
     state: PluginState;
 }): Promise<{
     existing: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/junior-scheduler",
-  "version": "0.75.0",
+  "version": "0.76.0",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -26,7 +26,7 @@
     "@sinclair/typebox": "^0.34.49",
     "drizzle-orm": "^0.45.2",
     "zod": "^4.4.3",
-    "@sentry/junior-plugin-api": "0.75.0"
+    "@sentry/junior-plugin-api": "0.76.0"
   },
   "devDependencies": {
     "@types/node": "^25.9.1",

package/src/index.ts

@@ -11,6 +11,7 @@ export {
   createSchedulerOperationalSqlStore,
   createSchedulerSqlStore,
   migrateSchedulerStateToSql,
+  type SchedulerDb,
 } from "./store";
 export type {
   ScheduledCalendarFrequency,

package/src/plugin.ts

@@ -1,7 +1,7 @@
 import {
+  createSlackSource,
   defineJuniorPlugin,
   type Dispatch,
-  type PluginDb,
   type PluginToolDefinition,
   type PluginOperationalReportContent,
   type PluginReadState,
@@ -14,6 +14,7 @@ import {
   createSchedulerOperationalSqlStore,
   createSchedulerSqlStore,
   migrateSchedulerStateToSql,
+  type SchedulerDb,
   type SchedulerOperationalStore,
   type SchedulerStore,
 } from "./store";
@@ -76,27 +77,20 @@ function buildScheduledTaskDispatchMetadata(args: {
 }
 
 function scheduledTaskDispatchSource(task: ScheduledTask): Source {
-  return {
-    platform: "slack",
+  return createSlackSource({
     teamId: task.destination.teamId,
     channelId: task.destination.channelId,
-  };
+  });
 }
 
-function schedulerStore(ctx: { db?: PluginDb }): SchedulerStore {
-  if (!ctx.db) {
-    throw new Error("Scheduler plugin requires ctx.db");
-  }
-  return createSchedulerSqlStore(ctx.db);
+function schedulerStore(ctx: { db: unknown }): SchedulerStore {
+  return createSchedulerSqlStore(ctx.db as SchedulerDb);
 }
 
 function schedulerOperationalStore(ctx: {
-  db?: PluginDb;
+  db: unknown;
 }): SchedulerOperationalStore {
-  if (!ctx.db) {
-    throw new Error("Scheduler plugin requires ctx.db");
-  }
-  return createSchedulerOperationalSqlStore(ctx.db);
+  return createSchedulerOperationalSqlStore(ctx.db as SchedulerDb);
 }
 
 function shouldSkipRun(
@@ -123,14 +117,7 @@ function createSchedulerToolContext(
 ): SchedulerToolContext {
   return {
     credentialSubject: ctx.slack?.credentialSubject,
-    source:
-      ctx.source.platform === "slack"
-        ? {
-            platform: "slack",
-            teamId: ctx.source.teamId,
-            channelId: ctx.source.channelId,
-          }
-        : undefined,
+    source: ctx.source.platform === "slack" ? ctx.source : undefined,
     requester: ctx.requester?.platform === "slack" ? ctx.requester : undefined,
     store: schedulerStore(ctx),
     userText: ctx.userText,
@@ -430,7 +417,6 @@ async function buildSchedulerOperationalReport(args: {
 /** Create Junior's built-in trusted scheduler plugin. */
 export function createSchedulerPlugin() {
   return defineJuniorPlugin({
-    database: {},
     manifest: {
       name: "scheduler",
       displayName: "Scheduler",
@@ -575,11 +561,8 @@ export function createSchedulerPlugin() {
         });
       },
       async migrateStorage(ctx) {
-        if (!ctx.db) {
-          throw new Error("Scheduler storage migration requires ctx.db");
-        }
         return await migrateSchedulerStateToSql({
-          db: ctx.db,
+          db: ctx.db as SchedulerDb,
           state: ctx.state,
         });
       },
@@ -587,5 +570,5 @@ export function createSchedulerPlugin() {
   });
 }
 
-/** Register trusted scheduler runtime hooks for scheduled Junior tasks. */
+/** Register scheduler runtime hooks for scheduled Junior tasks. */
 export const schedulerPlugin = createSchedulerPlugin;

package/src/schedule-tools.ts

@@ -3,12 +3,12 @@ import { Type } from "@sinclair/typebox";
 import {
   PluginToolInputError,
   pluginCredentialSubjectSchema,
-  destinationSchema,
-  isSlackDestination,
+  sourceSchema,
   type PluginCredentialSubject,
   type PluginToolDefinition,
   type SlackDestination,
   type SlackRequester,
+  type SlackSource,
 } from "@sentry/junior-plugin-api";
 import { buildCalendarRecurrence, parseScheduleTimestamp } from "./cadence";
 import { sanitizeScheduledTaskPrincipal } from "./identity";
@@ -26,7 +26,7 @@ import type {
 export interface SchedulerToolContext {
   credentialSubject?: PluginCredentialSubject;
   requester?: SlackRequester;
-  source?: SlackDestination;
+  source?: SlackSource;
   store: SchedulerStore;
   userText?: string;
 }
@@ -47,9 +47,9 @@ function throwToolInputError(error: string): never {
 function requireActiveConversation(
   context: SchedulerToolContext,
 ): SlackDestination {
-  const parsed = destinationSchema.safeParse(context.source);
+  const parsed = sourceSchema.safeParse(context.source);
   if (!parsed.success) {
-    const source = context.source as Partial<SlackDestination> | undefined;
+    const source = context.source as Partial<SlackSource> | undefined;
     const issues = parsed.error.issues as readonly SchemaIssue[];
     if (!source || source.platform !== "slack") {
       throwToolInputError("No active Slack conversation is available.");
@@ -68,11 +68,15 @@ function requireActiveConversation(
     throwToolInputError("No active Slack conversation is available.");
   }
 
-  if (!isSlackDestination(parsed.data)) {
+  if (parsed.data.platform !== "slack") {
     throwToolInputError("No active Slack conversation is available.");
   }
 
-  return parsed.data;
+  return {
+    platform: "slack",
+    teamId: parsed.data.teamId,
+    channelId: parsed.data.channelId,
+  };
 }
 
 function requireRequester(

package/src/store.ts

@@ -2,12 +2,26 @@ import {
   pluginCredentialSubjectSchema,
   destinationSchema,
   isSlackDestination,
-  type PluginDb,
   type PluginReadState,
   type PluginState,
 } from "@sentry/junior-plugin-api";
+import {
+  and,
+  asc,
+  eq,
+  inArray,
+  isNotNull,
+  lte,
+  ne,
+  or,
+  sql,
+} from "drizzle-orm";
+import type { PgDatabase } from "drizzle-orm/pg-core";
+import type { PgQueryResultHKT } from "drizzle-orm/pg-core/session";
 import { z } from "zod";
 import { getNextRunAtMs } from "./cadence";
+import * as schedulerSqlSchema from "./db/schema";
+import { juniorSchedulerRuns, juniorSchedulerTasks } from "./db/schema";
 import type { ScheduledRun, ScheduledTask } from "./types";
 
 const SCHEDULER_KEY_PREFIX = "junior:scheduler";
@@ -18,6 +32,10 @@ const PENDING_CLAIM_STALE_MS = 60_000;
 const MISSED_RUN_MAX_AGE_MS = 24 * 60 * 60 * 1000;
 const LOCK_TTL_MS = 10_000;
 const SQL_INCOMPLETE_RUN_STATUSES = ["pending", "running"] as const;
+export type SchedulerDb = PgDatabase<
+  PgQueryResultHKT,
+  typeof schedulerSqlSchema
+>;
 const slackDestinationSchema = destinationSchema.refine(isSlackDestination);
 const taskPrincipalSchema = z
   .object({
@@ -1055,161 +1073,150 @@ function parseSqlRunRow(row: SchedulerRunRow): ScheduledRun | undefined {
   return parsed.success ? stripLegacyRunFields(parsed.data) : undefined;
 }
 
-function json(value: unknown): string {
-  return JSON.stringify(value);
-}
-
 async function withSqlLock<T>(
-  db: PluginDb,
+  db: SchedulerDb,
   key: string,
-  callback: (db: PluginDb) => Promise<T>,
+  callback: (db: SchedulerDb) => Promise<T>,
 ): Promise<T> {
   return await db.transaction(async (tx) => {
-    await tx.execute("SELECT pg_advisory_xact_lock(hashtext($1))", [key]);
+    await tx.execute(sql`SELECT pg_advisory_xact_lock(hashtext(${key}))`);
     return await callback(tx);
   });
 }
 
-async function upsertSqlTask(db: PluginDb, task: ScheduledTask): Promise<void> {
-  await db.execute(
-    `
-INSERT INTO junior_scheduler_tasks (
-  id,
-  team_id,
-  status,
-  next_run_at_ms,
-  run_now_at_ms,
-  created_at_ms,
-  record
-) VALUES (
-  $1, $2, $3, $4, $5, $6, $7::jsonb
-)
-ON CONFLICT (id) DO UPDATE SET
-  team_id = EXCLUDED.team_id,
-  status = EXCLUDED.status,
-  next_run_at_ms = EXCLUDED.next_run_at_ms,
-  run_now_at_ms = EXCLUDED.run_now_at_ms,
-  created_at_ms = EXCLUDED.created_at_ms,
-  record = EXCLUDED.record
-`,
-    [
-      task.id,
-      task.destination.teamId,
-      task.status,
-      task.nextRunAtMs ?? null,
-      task.runNowAtMs ?? null,
-      task.createdAtMs,
-      json(task),
-    ],
-  );
+async function upsertSqlTask(
+  db: SchedulerDb,
+  task: ScheduledTask,
+): Promise<void> {
+  await db
+    .insert(juniorSchedulerTasks)
+    .values({
+      createdAtMs: task.createdAtMs,
+      id: task.id,
+      nextRunAtMs: task.nextRunAtMs,
+      record: task,
+      runNowAtMs: task.runNowAtMs,
+      status: task.status,
+      teamId: task.destination.teamId,
+    })
+    .onConflictDoUpdate({
+      target: juniorSchedulerTasks.id,
+      set: {
+        createdAtMs: sql`excluded.created_at_ms`,
+        nextRunAtMs: sql`excluded.next_run_at_ms`,
+        record: sql`excluded.record`,
+        runNowAtMs: sql`excluded.run_now_at_ms`,
+        status: sql`excluded.status`,
+        teamId: sql`excluded.team_id`,
+      },
+    });
 }
 
-async function upsertSqlRun(db: PluginDb, run: ScheduledRun): Promise<void> {
-  await db.execute(
-    `
-INSERT INTO junior_scheduler_runs (
-  id,
-  task_id,
-  status,
-  scheduled_for_ms,
-  record
-) VALUES (
-  $1, $2, $3, $4, $5::jsonb
-)
-ON CONFLICT (id) DO UPDATE SET
-  task_id = EXCLUDED.task_id,
-  status = EXCLUDED.status,
-  scheduled_for_ms = EXCLUDED.scheduled_for_ms,
-  record = EXCLUDED.record
-`,
-    [run.id, run.taskId, run.status, run.scheduledForMs, json(run)],
-  );
+async function upsertSqlRun(db: SchedulerDb, run: ScheduledRun): Promise<void> {
+  await db
+    .insert(juniorSchedulerRuns)
+    .values({
+      id: run.id,
+      record: run,
+      scheduledForMs: run.scheduledForMs,
+      status: run.status,
+      taskId: run.taskId,
+    })
+    .onConflictDoUpdate({
+      target: juniorSchedulerRuns.id,
+      set: {
+        record: sql`excluded.record`,
+        scheduledForMs: sql`excluded.scheduled_for_ms`,
+        status: sql`excluded.status`,
+        taskId: sql`excluded.task_id`,
+      },
+    });
 }
 
 async function getTaskFromSql(
-  db: PluginDb,
+  db: SchedulerDb,
   taskId: string,
 ): Promise<ScheduledTask | undefined> {
-  const rows = await db.query<SchedulerTaskRow>(
-    "SELECT record FROM junior_scheduler_tasks WHERE id = $1",
-    [taskId],
-  );
+  const rows = await db
+    .select({ record: juniorSchedulerTasks.record })
+    .from(juniorSchedulerTasks)
+    .where(eq(juniorSchedulerTasks.id, taskId))
+    .limit(1);
   return rows[0] ? parseSqlTaskRow(rows[0]) : undefined;
 }
 
 async function getRunFromSql(
-  db: PluginDb,
-  runId: string,
-): Promise<ScheduledRun | undefined> {
-  const rows = await db.query<SchedulerRunRow>(
-    "SELECT record FROM junior_scheduler_runs WHERE id = $1",
-    [runId],
-  );
-  return rows[0] ? parseSqlRunRow(rows[0]) : undefined;
-}
-
-async function getClaimedRunSlotFromSql(
-  db: PluginDb,
+  db: SchedulerDb,
   runId: string,
 ): Promise<ScheduledRun | undefined> {
-  const rows = await db.query<SchedulerRunRow>(
-    "SELECT record FROM junior_scheduler_runs WHERE id = $1",
-    [runId],
-  );
+  const rows = await db
+    .select({ record: juniorSchedulerRuns.record })
+    .from(juniorSchedulerRuns)
+    .where(eq(juniorSchedulerRuns.id, runId))
+    .limit(1);
   return rows[0] ? parseSqlRunRow(rows[0]) : undefined;
 }
 
-async function listTasksFromSql(db: PluginDb): Promise<ScheduledTask[]> {
-  const rows = await db.query<SchedulerTaskRow>(
-    `
-SELECT record
-FROM junior_scheduler_tasks
-WHERE status <> 'deleted'
-ORDER BY created_at_ms ASC, id ASC
-`,
-  );
+async function listTasksFromSql(db: SchedulerDb): Promise<ScheduledTask[]> {
+  const rows = await db
+    .select({ record: juniorSchedulerTasks.record })
+    .from(juniorSchedulerTasks)
+    .where(ne(juniorSchedulerTasks.status, "deleted"))
+    .orderBy(
+      asc(juniorSchedulerTasks.createdAtMs),
+      asc(juniorSchedulerTasks.id),
+    );
   return rows.map(parseSqlTaskRow).filter(present);
 }
 
 async function listTasksForTeamFromSql(
-  db: PluginDb,
+  db: SchedulerDb,
   teamId: string,
 ): Promise<ScheduledTask[]> {
-  const rows = await db.query<SchedulerTaskRow>(
-    `
-SELECT record
-FROM junior_scheduler_tasks
-WHERE team_id = $1
-  AND status <> 'deleted'
-ORDER BY created_at_ms ASC, id ASC
-`,
-    [teamId],
-  );
+  const rows = await db
+    .select({ record: juniorSchedulerTasks.record })
+    .from(juniorSchedulerTasks)
+    .where(
+      and(
+        eq(juniorSchedulerTasks.teamId, teamId),
+        ne(juniorSchedulerTasks.status, "deleted"),
+      ),
+    )
+    .orderBy(
+      asc(juniorSchedulerTasks.createdAtMs),
+      asc(juniorSchedulerTasks.id),
+    );
   return rows.map(parseSqlTaskRow).filter(present);
 }
 
 async function listIncompleteRunsForTasksFromSql(
-  db: PluginDb,
+  db: SchedulerDb,
   tasks: ScheduledTask[],
 ): Promise<ScheduledRun[]> {
   if (tasks.length === 0) {
     return [];
   }
-  const rows = await db.query<SchedulerRunRow>(
-    `
-SELECT record
-FROM junior_scheduler_runs
-WHERE task_id = ANY($1)
-  AND status = ANY($2)
-ORDER BY scheduled_for_ms ASC, id ASC
-`,
-    [tasks.map((task) => task.id), [...SQL_INCOMPLETE_RUN_STATUSES]],
-  );
+  const rows = await db
+    .select({ record: juniorSchedulerRuns.record })
+    .from(juniorSchedulerRuns)
+    .where(
+      and(
+        inArray(
+          juniorSchedulerRuns.taskId,
+          tasks.map((task) => task.id),
+        ),
+        inArray(juniorSchedulerRuns.status, [...SQL_INCOMPLETE_RUN_STATUSES]),
+      ),
+    )
+    .orderBy(
+      asc(juniorSchedulerRuns.scheduledForMs),
+      asc(juniorSchedulerRuns.id),
+    );
   return rows.map(parseSqlRunRow).filter(present);
 }
 
 class SqlSchedulerStore implements SchedulerStore, SchedulerOperationalStore {
-  constructor(private readonly db: PluginDb) {}
+  constructor(private readonly db: SchedulerDb) {}
 
   async saveTask(task: ScheduledTask): Promise<void> {
     const next = requireStoredTask(task);
@@ -1220,7 +1227,7 @@ class SqlSchedulerStore implements SchedulerStore, SchedulerOperationalStore {
   }
 
   private async saveTaskRecord(
-    db: PluginDb,
+    db: SchedulerDb,
     task: ScheduledTask,
     current: ScheduledTask | undefined,
   ): Promise<void> {
@@ -1232,10 +1239,14 @@ class SqlSchedulerStore implements SchedulerStore, SchedulerOperationalStore {
       typeof task.nextRunAtMs === "number" &&
       Number.isFinite(task.nextRunAtMs)
     ) {
-      await db.execute(
-        "DELETE FROM junior_scheduler_runs WHERE id = $1 AND status = 'blocked'",
-        [buildRunId(task.id, task.nextRunAtMs)],
-      );
+      await db
+        .delete(juniorSchedulerRuns)
+        .where(
+          and(
+            eq(juniorSchedulerRuns.id, buildRunId(task.id, task.nextRunAtMs)),
+            eq(juniorSchedulerRuns.status, "blocked"),
+          ),
+        );
     }
     await upsertSqlTask(db, task);
   }
@@ -1256,19 +1267,28 @@ class SqlSchedulerStore implements SchedulerStore, SchedulerOperationalStore {
     nowMs: number;
   }): Promise<ScheduledRun | undefined> {
     return await withSqlLock(this.db, "junior:scheduler:claim", async (db) => {
-      const rows = await db.query<SchedulerTaskRow>(
-        `
-SELECT record
-FROM junior_scheduler_tasks
-WHERE status = 'active'
-  AND (
-    (run_now_at_ms IS NOT NULL AND run_now_at_ms <= $1)
-    OR (next_run_at_ms IS NOT NULL AND next_run_at_ms <= $1)
-  )
-ORDER BY created_at_ms ASC, id ASC
-`,
-        [args.nowMs],
-      );
+      const rows = await db
+        .select({ record: juniorSchedulerTasks.record })
+        .from(juniorSchedulerTasks)
+        .where(
+          and(
+            eq(juniorSchedulerTasks.status, "active"),
+            or(
+              and(
+                isNotNull(juniorSchedulerTasks.runNowAtMs),
+                lte(juniorSchedulerTasks.runNowAtMs, args.nowMs),
+              ),
+              and(
+                isNotNull(juniorSchedulerTasks.nextRunAtMs),
+                lte(juniorSchedulerTasks.nextRunAtMs, args.nowMs),
+              ),
+            ),
+          ),
+        )
+        .orderBy(
+          asc(juniorSchedulerTasks.createdAtMs),
+          asc(juniorSchedulerTasks.id),
+        );
 
       for (const row of rows) {
         const task = parseSqlTaskRow(row);
@@ -1302,7 +1322,7 @@ ORDER BY created_at_ms ASC, id ASC
           await upsertSqlRun(db, reclaimed);
           return reclaimed;
         }
-        const existingRun = await getClaimedRunSlotFromSql(db, runId);
+        const existingRun = await getRunFromSql(db, runId);
         if (existingRun) {
           continue;
         }
@@ -1330,7 +1350,7 @@ ORDER BY created_at_ms ASC, id ASC
   }
 
   private async skipMissedRun(
-    db: PluginDb,
+    db: SchedulerDb,
     args: {
       nowMs: number;
       scheduledForMs: number;
@@ -1387,7 +1407,7 @@ ORDER BY created_at_ms ASC, id ASC
   }
 
   private async findStaleRecoveryCanonicalTask(
-    db: PluginDb,
+    db: SchedulerDb,
     task: ScheduledTask,
   ): Promise<ScheduledTask | undefined> {
     const fingerprint = taskDedupeFingerprint(task);
@@ -1625,20 +1645,20 @@ ORDER BY created_at_ms ASC, id ASC
 }
 
 /** Create a scheduler store backed by the plugin SQL database. */
-export function createSchedulerSqlStore(db: PluginDb): SchedulerStore {
+export function createSchedulerSqlStore(db: SchedulerDb): SchedulerStore {
   return new SqlSchedulerStore(db);
 }
 
 /** Create a read-only scheduler operational store backed by SQL. */
 export function createSchedulerOperationalSqlStore(
-  db: PluginDb,
+  db: SchedulerDb,
 ): SchedulerOperationalStore {
   return new SqlSchedulerStore(db);
 }
 
 /** Copy retained scheduler plugin-state records into the scheduler SQL tables. */
 export async function migrateSchedulerStateToSql(args: {
-  db: PluginDb;
+  db: SchedulerDb;
   state: PluginState;
 }): Promise<{
   existing: number;