rivetkit 2.3.4 → 2.3.5-rc.1

package/dist/browser/client.d.ts

@@ -23,6 +23,10 @@ interface SqliteExecuteResult extends SqliteQueryResult {
     changes: number;
     lastInsertRowId?: number | null;
 }
+interface SqliteBatchStatement {
+    sql: string;
+    params?: SqliteBindings;
+}
 interface SqliteNativeMetrics {
     requestBuildNs: number;
     serializeNs: number;
@@ -39,11 +43,19 @@ interface SqliteNativeMetrics {
 interface SqliteDatabase {
     exec(sql: string, callback?: (row: unknown[], columns: string[]) => void): Promise<void>;
     execute(sql: string, params?: SqliteBindings): Promise<SqliteExecuteResult>;
+    executeBatch(statements: SqliteBatchStatement[]): Promise<SqliteExecuteResult[]>;
+    beginTransaction(timeoutMs?: number): Promise<SqliteTransactionDatabase>;
     run(sql: string, params?: SqliteBindings): Promise<void>;
     query(sql: string, params?: SqliteBindings): Promise<SqliteQueryResult>;
     nativeMetrics?(): SqliteNativeMetrics | Promise<SqliteNativeMetrics | null> | null;
     close(): Promise<void>;
 }
+interface SqliteTransactionDatabase {
+    exec(sql: string, callback?: (row: unknown[], columns: string[]) => void): Promise<void>;
+    execute(sql: string, params?: SqliteBindings): Promise<SqliteExecuteResult>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+}
 /**
  * Provider for opening native databases from the active runtime.
  */
@@ -110,6 +122,10 @@ type RawAccess = {
      * Executes a raw SQL query.
      */
     execute: ExecuteFunction;
+    /** Runs a callback in an isolated SQLite transaction. */
+    transaction: <T>(callback: (tx: RawAccess) => Promise<T> | T, options?: {
+        timeout?: number;
+    }) => Promise<T>;
     /**
      * Returns native SQLite metrics when the active runtime supports them.
      */
@@ -305,11 +321,6 @@ interface EngineControlClient {
      * Test-only helper that simulates an abrupt actor crash.
      */
     hardCrashActor?(actorId: string): Promise<void>;
-    kvGet(actorId: string, key: Uint8Array): Promise<string | null>;
-    kvBatchGet(actorId: string, keys: Uint8Array[]): Promise<(Uint8Array | null)[]>;
-    kvBatchPut(actorId: string, entries: [Uint8Array, Uint8Array][]): Promise<void>;
-    kvBatchDelete(actorId: string, keys: Uint8Array[]): Promise<void>;
-    kvDeleteRange(actorId: string, start: Uint8Array, end: Uint8Array): Promise<void>;
 }
 interface RuntimeDisplayInformation {
     properties: Record<string, string>;
@@ -1001,10 +1012,76 @@ interface ActorKv {
     [key: string]: any;
 }
 interface ActorSchedule {
-    after(duration: number, action: string, ...args: unknown[]): Promise<void>;
-    at(timestamp: number, action: string, ...args: unknown[]): Promise<void>;
+    after(duration: number, action: string, ...args: unknown[]): Promise<string>;
+    at(timestamp: number, action: string, ...args: unknown[]): Promise<string>;
+    cancel(id: string): Promise<boolean>;
+    get(id: string): Promise<ScheduledEventInfo | undefined>;
+    list(): Promise<ScheduledEventInfo[]>;
     [key: string]: any;
 }
+interface ActorCronSetOptions {
+    name: string;
+    expression: string;
+    action: string;
+    args?: unknown[];
+    timezone?: string;
+    /** Defaults to 100. Set to 0 to disable and clear history. Maximum 1,000. */
+    maxHistory?: number;
+}
+interface ActorCronEveryOptions {
+    name: string;
+    /** Fixed interval in milliseconds. Minimum 5,000. */
+    interval: number;
+    action: string;
+    args?: unknown[];
+    /** Defaults to 100. Set to 0 to disable and clear history. Maximum 1,000. */
+    maxHistory?: number;
+}
+interface ActorCron {
+    set(options: ActorCronSetOptions): Promise<void>;
+    every(options: ActorCronEveryOptions): Promise<void>;
+    get(name: string): Promise<CronJobInfo | undefined>;
+    list(): Promise<CronJobInfo[]>;
+    delete(name: string): Promise<boolean>;
+    history(name: string, options?: {
+        limit?: number;
+    }): Promise<CronFire[]>;
+    [key: string]: any;
+}
+interface ScheduledEventInfo {
+    id: string;
+    action: string;
+    args: unknown[];
+    runAt: number;
+}
+type CronJobInfo = {
+    name: string;
+    action: string;
+    args: unknown[];
+    nextRunAt: number;
+    lastRunAt?: number;
+    maxHistory: number;
+} & ({
+    kind: "cron";
+    expression: string;
+    timezone: string;
+} | {
+    kind: "every";
+    interval: number;
+});
+interface CronFire {
+    action: string;
+    scheduledAt: number;
+    firedAt: number;
+    finishedAt?: number;
+    result: "running" | "ok" | "error" | "skipped";
+    error?: {
+        group: string;
+        code: string;
+        message: string;
+        metadata?: unknown;
+    };
+}
 type QueueMessageOf<Name extends string, Body> = {
     id: number | bigint;
     name: Name;
@@ -1085,11 +1162,16 @@ interface ActorContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase
     readonly kv: ActorKv;
     readonly db: InferDatabaseClient<TDatabase>;
     readonly schedule: ActorSchedule;
+    readonly cron: ActorCron;
     readonly queue: ActorQueue<TQueues>;
     readonly actorId: string;
     readonly name: string;
     readonly key: string[];
     readonly region: string;
+    /** Provisions the experimental Actor Runtime Socket for this actor generation. */
+    actorRuntimeSocket(): Promise<{
+        path: string;
+    }>;
     readonly conns: Map<string, Conn<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>>;
     readonly log: ActorLogger;
     readonly abortSignal: AbortSignal;
@@ -1186,6 +1268,7 @@ declare const ActorConfigSchema: z.ZodObject<{
     options: z.ZodPrefault<z.ZodObject<{
         name: z.ZodOptional<z.ZodString>;
         icon: z.ZodOptional<z.ZodString>;
+        enableActorRuntimeSocket: z.ZodDefault<z.ZodBoolean>;
         canHibernateWebSocket: z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodCustom<(request: Request) => boolean, (request: Request) => boolean>]>>;
         createVarsTimeout: z.ZodDefault<z.ZodNumber>;
         createConnStateTimeout: z.ZodDefault<z.ZodNumber>;
@@ -1202,6 +1285,7 @@ declare const ActorConfigSchema: z.ZodObject<{
         noSleep: z.ZodDefault<z.ZodBoolean>;
         sleepTimeout: z.ZodDefault<z.ZodNumber>;
         maxQueueSize: z.ZodDefault<z.ZodNumber>;
+        maxSchedules: z.ZodDefault<z.ZodNumber>;
         maxQueueMessageSize: z.ZodDefault<z.ZodNumber>;
         preloadMaxWorkflowBytes: z.ZodOptional<z.ZodNumber>;
         preloadMaxConnectionsBytes: z.ZodOptional<z.ZodNumber>;
@@ -1219,6 +1303,7 @@ declare const ActorConfigSchema: z.ZodObject<{
                 workflow: "workflow";
                 database: "database";
                 queue: "queue";
+                schedules: "schedules";
                 connections: "connections";
                 console: "console";
             }>;
@@ -1663,6 +1748,7 @@ type ActorContextHandle = OpaqueHandle<"actorContext">;
 type ConnHandle = OpaqueHandle<"conn">;
 type WebSocketHandle = OpaqueHandle<"webSocket">;
 type CancellationTokenHandle = OpaqueHandle<"cancellationToken">;
+type SqliteTransactionHandle = OpaqueHandle<"sqliteTransaction">;
 type RuntimeBytes = Uint8Array;
 interface RuntimeActorKeySegment {
     kind: string;
@@ -1683,6 +1769,10 @@ interface RuntimeStateDeltaPayload {
     }>;
     connHibernationRemoved: string[];
 }
+interface RuntimeWorkflowKvWrite {
+    key: RuntimeBytes;
+    value: RuntimeBytes;
+}
 interface RuntimeRequestSaveOpts {
     immediate?: boolean;
     maxWaitMs?: number;
@@ -1708,6 +1798,38 @@ interface RuntimeQueueInspectMessage {
     name: string;
     createdAtMs: number;
 }
+interface RuntimeScheduledEventInfo {
+    id: string;
+    action: string;
+    args: RuntimeBytes;
+    runAt: number;
+}
+interface RuntimeCronJobInfo {
+    name: string;
+    kind: "cron" | "every";
+    action: string;
+    args: RuntimeBytes;
+    nextRunAt: number;
+    lastRunAt?: number;
+    expression?: string;
+    timezone?: string;
+    intervalMs?: number;
+    maxHistory: number;
+}
+interface RuntimeScheduleErrorInfo {
+    group: string;
+    code: string;
+    message: string;
+    metadata?: unknown;
+}
+interface RuntimeCronFire {
+    action: string;
+    scheduledAt: number;
+    firedAt: number;
+    finishedAt?: number;
+    result: "running" | "ok" | "error" | "skipped";
+    error?: RuntimeScheduleErrorInfo;
+}
 interface RuntimeQueueNextBatchOptions {
     names?: string[];
     count?: number;
@@ -1768,6 +1890,9 @@ type RuntimeSqlBindParam = ({
     blobValue: RuntimeBytes;
 };
 type RuntimeSqlBindParams = RuntimeSqlBindParam[] | null;
+interface RuntimeActorRuntimeSocketEndpointInfo {
+    path: string;
+}
 interface RuntimeSqlQueryResult {
     columns: string[];
     rows: unknown[][];
@@ -1777,6 +1902,10 @@ interface RuntimeSqlExecuteResult extends RuntimeSqlQueryResult {
     changes: number;
     lastInsertRowId?: number | null;
 }
+interface RuntimeSqlBatchStatement {
+    sql: string;
+    params?: RuntimeSqlBindParams;
+}
 interface RuntimeSqlRunResult {
     changes: number;
 }
@@ -1785,6 +1914,7 @@ interface RuntimeActorConfig {
     icon?: string;
     hasDatabase?: boolean;
     remoteSqlite?: boolean;
+    enableActorRuntimeSocket?: boolean;
     hasState?: boolean;
     canHibernateWebsocket?: boolean;
     stateSaveIntervalMs?: number;
@@ -1805,6 +1935,7 @@ interface RuntimeActorConfig {
     connectionLivenessTimeoutMs?: number;
     connectionLivenessIntervalMs?: number;
     maxQueueSize?: number;
+    maxSchedules?: number;
     maxQueueMessageSize?: number;
     maxIncomingMessageSize?: number;
     maxOutgoingMessageSize?: number;
@@ -1922,6 +2053,7 @@ interface CoreRuntime {
     actorTakePendingHibernationChanges(ctx: ActorContextHandle): string[];
     actorDirtyHibernatableConns(ctx: ActorContextHandle): ConnHandle[];
     actorSaveState(ctx: ActorContextHandle, payload: RuntimeStateDeltaPayload): Promise<void>;
+    actorSaveStateAndWorkflowBatch(ctx: ActorContextHandle, writes: RuntimeWorkflowKvWrite[]): Promise<void>;
     actorId(ctx: ActorContextHandle): string;
     actorName(ctx: ActorContextHandle): string;
     actorKey(ctx: ActorContextHandle): RuntimeActorKeySegment[];
@@ -1955,11 +2087,18 @@ interface CoreRuntime {
     actorKvBatchDelete(ctx: ActorContextHandle, keys: RuntimeBytes[]): Promise<void>;
     actorSqlExec(ctx: ActorContextHandle, sql: string): Promise<RuntimeSqlExecResult>;
     actorSqlExecute(ctx: ActorContextHandle, sql: string, params?: RuntimeSqlBindParams): Promise<RuntimeSqlExecuteResult>;
+    actorSqlExecuteBatch(ctx: ActorContextHandle, statements: RuntimeSqlBatchStatement[]): Promise<RuntimeSqlExecuteResult[]>;
+    actorSqlBeginTransaction(ctx: ActorContextHandle, timeoutMs?: number): Promise<SqliteTransactionHandle>;
+    actorSqlTransactionExec(transaction: SqliteTransactionHandle, sql: string): Promise<RuntimeSqlExecResult>;
+    actorSqlTransactionExecute(transaction: SqliteTransactionHandle, sql: string, params?: RuntimeSqlBindParams): Promise<RuntimeSqlExecuteResult>;
+    actorSqlTransactionCommit(transaction: SqliteTransactionHandle): Promise<void>;
+    actorSqlTransactionRollback(transaction: SqliteTransactionHandle): Promise<void>;
     actorSqlQuery(ctx: ActorContextHandle, sql: string, params?: RuntimeSqlBindParams): Promise<RuntimeSqlQueryResult>;
     actorSqlRun(ctx: ActorContextHandle, sql: string, params?: RuntimeSqlBindParams): Promise<RuntimeSqlRunResult>;
     actorSqlMetrics(ctx: ActorContextHandle): SqliteNativeMetrics | null;
     actorSqlTakeLastKvError(ctx: ActorContextHandle): string | null;
     actorSqlClose(ctx: ActorContextHandle): Promise<void>;
+    actorRuntimeSocketProvision(ctx: ActorContextHandle): Promise<RuntimeActorRuntimeSocketEndpointInfo>;
     actorQueueSend(ctx: ActorContextHandle, name: string, body: RuntimeBytes): Promise<RuntimeQueueMessage>;
     actorQueueNextBatch(ctx: ActorContextHandle, options?: RuntimeQueueNextBatchOptions | undefined | null, signal?: CancellationTokenHandle | undefined | null): Promise<RuntimeQueueMessage[]>;
     actorQueueWaitForNames(ctx: ActorContextHandle, names: string[], options?: RuntimeQueueWaitOptions | undefined | null, signal?: CancellationTokenHandle | undefined | null): Promise<RuntimeQueueMessage>;
@@ -1969,8 +2108,17 @@ interface CoreRuntime {
     actorQueueMaxSize(ctx: ActorContextHandle): number;
     actorQueueInspectMessages(ctx: ActorContextHandle): Promise<RuntimeQueueInspectMessage[]>;
     actorQueueReset(ctx: ActorContextHandle): Promise<void>;
-    actorScheduleAfter(ctx: ActorContextHandle, durationMs: number, actionName: string, args: RuntimeBytes): void;
-    actorScheduleAt(ctx: ActorContextHandle, timestampMs: number, actionName: string, args: RuntimeBytes): void;
+    actorScheduleAfter(ctx: ActorContextHandle, durationMs: number, actionName: string, args: RuntimeBytes): Promise<string>;
+    actorScheduleAt(ctx: ActorContextHandle, timestampMs: number, actionName: string, args: RuntimeBytes): Promise<string>;
+    actorScheduleCancel(ctx: ActorContextHandle, id: string): Promise<boolean>;
+    actorScheduleGet(ctx: ActorContextHandle, id: string): Promise<RuntimeScheduledEventInfo | undefined>;
+    actorScheduleList(ctx: ActorContextHandle): Promise<RuntimeScheduledEventInfo[]>;
+    actorCronSet(ctx: ActorContextHandle, name: string, expression: string, timezone: string | undefined, actionName: string, args: RuntimeBytes, maxHistory: number | undefined): Promise<void>;
+    actorCronEvery(ctx: ActorContextHandle, name: string, intervalMs: number, actionName: string, args: RuntimeBytes, maxHistory: number | undefined): Promise<void>;
+    actorCronGet(ctx: ActorContextHandle, name: string): Promise<RuntimeCronJobInfo | undefined>;
+    actorCronList(ctx: ActorContextHandle): Promise<RuntimeCronJobInfo[]>;
+    actorCronDelete(ctx: ActorContextHandle, name: string): Promise<boolean>;
+    actorCronHistory(ctx: ActorContextHandle, name: string, limit: number | undefined): Promise<RuntimeCronFire[]>;
     connId(conn: ConnHandle): string;
     connParams(conn: ConnHandle): RuntimeBytes;
     connState(conn: ConnHandle): RuntimeBytes;