@qlever-llc/trellis 0.10.22 → 0.11.0-rc.1

package/src/sdk/_generated/state/types.ts

@@ -1,6 +1,14 @@
 // Generated from ./generated/contracts/manifests/trellis.state@v1.json
-import type { RpcHandlerFn } from "../../../index.js";
-import type { API } from "./api.js";
+import type {
+  HandlerTrellis,
+  Result,
+  RpcHandlerContext,
+  TrellisErrorInstance,
+} from "../../../index.js";
+
+import type { Api } from "./api.js";
+
+export type HandlerClient = HandlerTrellis<Api>;
 
 export const CONTRACT_ID = "trellis.state@v1" as const;
 export const CONTRACT_DIGEST =
@@ -231,22 +239,90 @@ export interface RpcMap {
   "State.Put": { input: StatePutInput; output: StatePutOutput };
 }
 
-export type StateAdminDeleteHandler = RpcHandlerFn<
-  typeof API.owned,
-  "State.Admin.Delete"
+export type StateAdminDeleteHandlerError = TrellisErrorInstance;
+export type StateAdminDeleteHandlerResult = Result<
+  StateAdminDeleteOutput,
+  StateAdminDeleteHandlerError
+>;
+export type StateAdminDeleteHandler = (
+  args: {
+    input: StateAdminDeleteInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) => StateAdminDeleteHandlerResult | Promise<StateAdminDeleteHandlerResult>;
+export type StateAdminGetHandlerError = TrellisErrorInstance;
+export type StateAdminGetHandlerResult = Result<
+  StateAdminGetOutput,
+  StateAdminGetHandlerError
+>;
+export type StateAdminGetHandler = (
+  args: {
+    input: StateAdminGetInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) => StateAdminGetHandlerResult | Promise<StateAdminGetHandlerResult>;
+export type StateAdminListHandlerError = TrellisErrorInstance;
+export type StateAdminListHandlerResult = Result<
+  StateAdminListOutput,
+  StateAdminListHandlerError
+>;
+export type StateAdminListHandler = (
+  args: {
+    input: StateAdminListInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) => StateAdminListHandlerResult | Promise<StateAdminListHandlerResult>;
+export type StateDeleteHandlerError = TrellisErrorInstance;
+export type StateDeleteHandlerResult = Result<
+  StateDeleteOutput,
+  StateDeleteHandlerError
+>;
+export type StateDeleteHandler = (
+  args: {
+    input: StateDeleteInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) => StateDeleteHandlerResult | Promise<StateDeleteHandlerResult>;
+export type StateGetHandlerError = TrellisErrorInstance;
+export type StateGetHandlerResult = Result<
+  StateGetOutput,
+  StateGetHandlerError
 >;
-export type StateAdminGetHandler = RpcHandlerFn<
-  typeof API.owned,
-  "State.Admin.Get"
+export type StateGetHandler = (
+  args: {
+    input: StateGetInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) => StateGetHandlerResult | Promise<StateGetHandlerResult>;
+export type StateListHandlerError = TrellisErrorInstance;
+export type StateListHandlerResult = Result<
+  StateListOutput,
+  StateListHandlerError
 >;
-export type StateAdminListHandler = RpcHandlerFn<
-  typeof API.owned,
-  "State.Admin.List"
+export type StateListHandler = (
+  args: {
+    input: StateListInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) => StateListHandlerResult | Promise<StateListHandlerResult>;
+export type StatePutHandlerError = TrellisErrorInstance;
+export type StatePutHandlerResult = Result<
+  StatePutOutput,
+  StatePutHandlerError
 >;
-export type StateDeleteHandler = RpcHandlerFn<typeof API.owned, "State.Delete">;
-export type StateGetHandler = RpcHandlerFn<typeof API.owned, "State.Get">;
-export type StateListHandler = RpcHandlerFn<typeof API.owned, "State.List">;
-export type StatePutHandler = RpcHandlerFn<typeof API.owned, "State.Put">;
+export type StatePutHandler = (
+  args: {
+    input: StatePutInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) => StatePutHandlerResult | Promise<StatePutHandlerResult>;
 
 export interface EventMap {
 }

package/src/server/health.ts

@@ -63,10 +63,6 @@ export type ServiceHealthInfoFn = () => MaybePromise<
 >;
 
 export type HealthHeartbeat = {
-  header: {
-    id: string;
-    time: string;
-  };
   service: {
     name: string;
     kind: "service" | "device";
@@ -299,7 +295,7 @@ export function createHealthHeartbeat(args: {
   publishIntervalMs: number;
   checks: HealthCheckResult[];
   info?: ServiceHealthInfo;
-}): Omit<HealthHeartbeat, "header"> {
+}): HealthHeartbeat {
   const runtime = detectRuntime();
   const summary = summarizeHealthChecks(args.checks);
 
@@ -400,7 +396,7 @@ export class ServiceHealth {
     };
   }
 
-  async heartbeat(): Promise<Omit<HealthHeartbeat, "header">> {
+  async heartbeat(): Promise<HealthHeartbeat> {
     const checks = await this.checks();
     const info = this.#info ? await this.#info() : undefined;
     return createHealthHeartbeat({

package/src/server/health_schemas.ts

@@ -24,11 +24,6 @@ export const HealthResponseSchema = Type.Object({
   checks: Type.Array(HealthCheckResultSchema),
 });
 
-export const HealthHeartbeatHeaderSchema = Type.Object({
-  id: Type.String(),
-  time: Type.String({ format: "date-time" }),
-});
-
 export const HealthHeartbeatServiceSchema = Type.Object({
   name: Type.String(),
   kind: Type.Union([Type.Literal("service"), Type.Literal("device")]),
@@ -49,7 +44,6 @@ export const HealthHeartbeatServiceSchema = Type.Object({
 });
 
 export const HealthHeartbeatSchema = Type.Object({
-  header: HealthHeartbeatHeaderSchema,
   service: HealthHeartbeatServiceSchema,
   status: Type.Union([
     Type.Literal("healthy"),

package/src/server/internal_jobs/bindings.ts

@@ -13,6 +13,17 @@ export type JobsQueueBinding = {
   logs: boolean;
   dlq: boolean;
   concurrency: number;
+  keyConcurrency?: {
+    key: string[];
+    maxActive: number;
+    heartbeatIntervalMs: number;
+    heartbeatTtlMs: number;
+    stalePolicy: "fail-stale" | "block";
+  };
+  queue?: {
+    maxQueuedPerKey: number;
+    whenFull: "reject" | "coalesce" | "replace-oldest";
+  };
 };
 
 export type JobsBinding = {