partywhen/dist/index.d.ts

A library for scheduling and running tasks in Cloudflare Workers

import { Server } from "partyserver";

type RawTask = {
  id: string;
  description?: string | undefined;
  payload?: Record<string, unknown> | undefined;
  callback?: Callback | undefined;
} & (
  | {
      time: Date;
      type: "scheduled";
    }
  | {
      delayInSeconds: number;
      type: "delayed";
    }
  | {
      cron: string;
      type: "cron";
    }
  | {
      type: "no-schedule";
    }
);
type Task = RawTask & {
  time: Date;
};
type SqlTask = {
  id: string;
  description: string | null;
  payload: string | null;
  callback: string | null;
  created_at: number;
} & (
  | {
      type: "scheduled";
      time: number;
    }
  | {
      type: "delayed";
      time: number;
      delayInSeconds: number;
    }
  | {
      type: "cron";
      time: number;
      cron: string;
    }
  | {
      type: "no-schedule";
      time: number;
    }
);
type Callback =
  | {
      type: "self";
      function: string;
    }
  | {
      type: "webhook";
      url: string;
    }
  | {
      type: "durable-object";
      namespace: string;
      name: string;
      function: string;
    }
  | {
      type: "service";
      service: string;
      function: string;
    };
declare class Scheduler<Env> extends Server<Env> {
  constructor(state: DurableObjectState, env: Env);
  status(): {
    status: "reachable";
    timestamp: number;
    diskUsage: number;
  };
  fetch(_request: Request): Promise<Response>;
  getAllTasks(): SqlResult<SqlTask>;
  private scheduleNextAlarm;
  scheduleTask(task: RawTask): Promise<Task>;
  alarm(): Promise<void>;
  private rowToTask;
  private executeTask;
  private getNextCronTime;
  query(criteria?: {
    description?: string;
    id?: string;
    type?: "scheduled" | "delayed" | "cron" | "no-schedule";
    timeRange?: {
      start?: Date;
      end?: Date;
    };
  }): Promise<Task[]>;
  cancelTask(id: string): Promise<boolean>;
  querySql<T>(qs: SqliteQuery[], isRaw?: boolean): SqlResult<T>;
  private executeTransaction;
  executeQuery<T>(
    sql: string,
    params: SqliteParams[] | undefined,
    isRaw: boolean
  ): QueryResponse<T>;
}
type SqlResult<T> =
  | {
      result: T[];
      error: null;
      status: 200;
    }
  | {
      result: null;
      error: string;
      status: 500 | 408;
    };
type RawSqliteResponse<T> = {
  columns: string[];
  rows: T[];
  meta: {
    rows_read: number;
    rows_written: number;
  };
};
type QueryResponse<T> = T[] | RawSqliteResponse<T>;
type SqliteParams = number | string | boolean | null;
type SqliteQuery = {
  sql?: string;
  params?: SqliteParams[];
};

export {
  type RawSqliteResponse,
  type RawTask,
  Scheduler,
  type SqlResult,
  type SqlTask,
  type SqliteParams,
  type SqliteQuery,
  type Task
};