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

package/src/sdk/_generated/core/api.ts

@@ -1,12 +1,34 @@
 // Generated from ./generated/contracts/manifests/trellis.core@v1.json
 import { OWNED_API } from "./owned_api.js";
+import { OWNED_API as HealthApi } from "../health/mod.js";
 
 export { OWNED_API };
 
+type __TrellisGeneratedOptionalOperationProgress<TDesc> = TDesc extends
+  { progress: infer TProgress } ? { progress?: TProgress }
+  : { progress?: undefined };
+type __TrellisGeneratedOptionalOperationOutput<TDesc> = TDesc extends
+  { output: infer TOutput } ? { output?: TOutput }
+  : { output?: undefined };
+type __TrellisGeneratedOptionalOperationIO<TDesc> = TDesc extends
+  { input: infer TInput } ?
+    & Omit<TDesc, "input" | "progress" | "output">
+    & {
+      input: TInput;
+    }
+    & __TrellisGeneratedOptionalOperationProgress<TDesc>
+    & __TrellisGeneratedOptionalOperationOutput<TDesc>
+  : TDesc;
+type __TrellisGeneratedOperationApi<TApi> = {
+  readonly [K in keyof TApi]: __TrellisGeneratedOptionalOperationIO<TApi[K]>;
+};
+
 export type UsedApi = {
   rpc: {};
   operations: {};
-  events: {};
+  events: {
+    readonly "Health.Heartbeat": typeof HealthApi.events["Health.Heartbeat"];
+  };
   feeds: {};
   subjects: {};
 };
@@ -14,12 +36,18 @@ export type UsedApi = {
 export const USED_API: UsedApi = {
   rpc: {},
   operations: {},
-  events: {},
+  events: {
+    get "Health.Heartbeat"() {
+      return HealthApi.events["Health.Heartbeat"];
+    },
+  },
   feeds: {},
   subjects: {},
 };
 
-export type OwnedApi = typeof OWNED_API;
+export type OwnedApi = Omit<typeof OWNED_API, "operations"> & {
+  operations: __TrellisGeneratedOperationApi<typeof OWNED_API["operations"]>;
+};
 export type Api = {
   rpc: OwnedApi["rpc"] & UsedApi["rpc"];
   operations: OwnedApi["operations"] & UsedApi["operations"];
@@ -28,9 +56,12 @@ export type Api = {
   subjects: OwnedApi["subjects"] & UsedApi["subjects"];
 };
 
-export const API = {
+export type ApiViews = {
+  owned: OwnedApi;
+  used: UsedApi;
+};
+
+export const API: ApiViews = {
   owned: OWNED_API,
   used: USED_API,
-} as const;
-
-export type ApiViews = typeof API;
+};

package/src/sdk/_generated/core/client.ts

@@ -15,13 +15,11 @@ import type {
   OperationRef,
   OperationRefData,
   OperationRuntimeHandle,
-  OperationTransferHandle,
   PreparedTrellisEvent,
   ReceiveTransferGrant,
   ReceiveTransferHandle,
   RequestOpts,
   Result,
-  RpcHandlerContext,
   SendTransferGrant,
   SendTransferHandle,
   TerminalOperation,
@@ -33,8 +31,7 @@ import type {
 } from "../../../index.js";
 import type { API, Api } from "./api.js";
 import type * as Types from "./types.js";
-
-type WithDeps<TDeps> = [TDeps] extends [undefined] ? {} : { deps: TDeps };
+import type * as HealthSdk from "../health/mod.js";
 
 type EventCallback<TMessage> = {
   bivarianceHack(
@@ -43,46 +40,10 @@ type EventCallback<TMessage> = {
   ): MaybeAsync<void, BaseError>;
 }["bivarianceHack"];
 
-type ServiceEventHandler<TEvent, TDeps = undefined> = (
-  args:
-    & { event: TEvent; context: EventListenerContext; client: HandlerClient }
-    & WithDeps<TDeps>,
+type DependencyServiceEventHandler<TEvent> = (
+  args: { event: TEvent; context: EventListenerContext; client: HandlerClient },
 ) => MaybeAsync<void, BaseError>;
 
-type RpcHandler<TInput, TOutput, TDeps = undefined> = (
-  args:
-    & { input: TInput; context: RpcHandlerContext; client: HandlerClient }
-    & WithDeps<TDeps>,
-) => MaybeAsync<TOutput, BaseError>;
-
-type FeedHandler<TInput, TEvent, TDeps = undefined> = (
-  context: {
-    input: TInput;
-    caller: unknown;
-    signal: AbortSignal;
-    emit(event: TEvent): AsyncResult<void, ValidationError | UnexpectedError>;
-    client: HandlerClient;
-  } & WithDeps<TDeps>,
-) => unknown | Promise<unknown>;
-
-type OperationHandler<
-  TInput,
-  TProgress,
-  TOutput,
-  TTransfer,
-  TDeps = undefined,
-> = (
-  context:
-    & {
-      input: TInput;
-      op: OperationRuntimeHandle<TProgress, TOutput>;
-      caller: unknown;
-      client: HandlerClient;
-    }
-    & TTransfer
-    & WithDeps<TDeps>,
-) => unknown | Promise<unknown>;
-
 export type TrellisCoreState = {};
 
 export interface TrellisCoreClient {
@@ -110,7 +71,26 @@ export interface TrellisCoreClient {
       ): AsyncResult<Types.TrellisSurfaceStatusOutput, BaseError>;
     };
   };
-  readonly event: {};
+  readonly event: {
+    readonly health: {
+      heartbeat: {
+        publish(
+          event: HealthSdk.HealthHeartbeatEvent,
+        ): AsyncResult<void, ValidationError | UnexpectedError>;
+        prepare(
+          event: HealthSdk.HealthHeartbeatEvent,
+        ): Result<
+          PreparedTrellisEvent<HealthSdk.HealthHeartbeatEvent>,
+          ValidationError | UnexpectedError
+        >;
+        listen(
+          handler: EventCallback<HealthSdk.HealthHeartbeatEvent>,
+          subjectData?: Record<string, unknown>,
+          opts?: EventOpts,
+        ): AsyncResult<void, ValidationError | UnexpectedError>;
+      };
+    };
+  };
   readonly feed: {};
   readonly operation: {};
   wait(): AsyncResult<void, BaseError>;
@@ -118,41 +98,35 @@ export interface TrellisCoreClient {
 
 export interface Service extends TrellisCoreClient {
   readonly handle: ServiceHandle;
-  with<TDeps>(deps: TDeps): ServiceWithDeps<TDeps>;
 }
 
-export type ServiceWithDeps<TDeps> = Omit<TrellisCoreClient, "event"> & {
-  readonly event: ServiceEventSurface<TDeps>;
-  readonly handle: ServiceHandle<TDeps>;
-  with<TNextDeps>(deps: TNextDeps): ServiceWithDeps<TNextDeps>;
-};
-
-export type ServiceEventSurface<TDeps> = {};
+export interface ServiceEventSurface {
+  readonly health: {
+    heartbeat: {
+      publish(
+        event: HealthSdk.HealthHeartbeatEvent,
+      ): AsyncResult<void, ValidationError | UnexpectedError>;
+      prepare(
+        event: HealthSdk.HealthHeartbeatEvent,
+      ): Result<
+        PreparedTrellisEvent<HealthSdk.HealthHeartbeatEvent>,
+        ValidationError | UnexpectedError
+      >;
+      listen(
+        handler: DependencyServiceEventHandler<HealthSdk.HealthHeartbeatEvent>,
+        subjectData?: Record<string, unknown>,
+        opts?: EventOpts,
+      ): AsyncResult<void, ValidationError | UnexpectedError>;
+    };
+  };
+}
 
-export interface ServiceHandle<TDeps = undefined> {
+export interface ServiceHandle {
   readonly rpc: {
     readonly trellis: {
-      catalog(
-        handler: RpcHandler<
-          Types.TrellisCatalogInput,
-          Types.TrellisCatalogOutput,
-          TDeps
-        >,
-      ): Promise<void>;
-      contractGet(
-        handler: RpcHandler<
-          Types.TrellisContractGetInput,
-          Types.TrellisContractGetOutput,
-          TDeps
-        >,
-      ): Promise<void>;
-      surfaceStatus(
-        handler: RpcHandler<
-          Types.TrellisSurfaceStatusInput,
-          Types.TrellisSurfaceStatusOutput,
-          TDeps
-        >,
-      ): Promise<void>;
+      catalog(handler: Types.TrellisCatalogHandler): Promise<void>;
+      contractGet(handler: Types.TrellisContractGetHandler): Promise<void>;
+      surfaceStatus(handler: Types.TrellisSurfaceStatusHandler): Promise<void>;
     };
   };
   readonly feed: {};

package/src/sdk/_generated/core/contract.ts

@@ -13,7 +13,7 @@ const CONTRACT_MODULE_METADATA = Symbol.for(
 
 export const CONTRACT_ID = "trellis.core@v1" as const;
 export const CONTRACT_DIGEST =
-  "L4HW6uUIxDhK1Kpa_PUxpumoMberMgiCgJTNN5Qvje0" as const;
+  "1vbZgyhBkgKDSkzqvkwItxObBfaLNdysxFBeTT-Ng2c" as const;
 export const CONTRACT = {
   "capabilities": {
     "trellis.core::catalog.read": {
@@ -170,6 +170,41 @@ export const CONTRACT = {
                               "type": "integer",
                             },
                             "dlq": { "type": "boolean" },
+                            "keyConcurrency": {
+                              "properties": {
+                                "heartbeatIntervalMs": {
+                                  "minimum": 1,
+                                  "type": "integer",
+                                },
+                                "heartbeatTtlMs": {
+                                  "minimum": 1,
+                                  "type": "integer",
+                                },
+                                "key": {
+                                  "items": { "minLength": 1, "type": "string" },
+                                  "minItems": 1,
+                                  "type": "array",
+                                },
+                                "maxActive": {
+                                  "minimum": 1,
+                                  "type": "integer",
+                                },
+                                "stalePolicy": {
+                                  "anyOf": [{
+                                    "const": "fail-stale",
+                                    "type": "string",
+                                  }, { "const": "block", "type": "string" }],
+                                },
+                              },
+                              "required": [
+                                "key",
+                                "maxActive",
+                                "heartbeatIntervalMs",
+                                "heartbeatTtlMs",
+                                "stalePolicy",
+                              ],
+                              "type": "object",
+                            },
                             "logs": { "type": "boolean" },
                             "maxDeliver": { "minimum": 1, "type": "integer" },
                             "payload": {
@@ -184,6 +219,26 @@ export const CONTRACT = {
                               "minLength": 1,
                               "type": "string",
                             },
+                            "queue": {
+                              "properties": {
+                                "maxQueuedPerKey": {
+                                  "minimum": 0,
+                                  "type": "integer",
+                                },
+                                "whenFull": {
+                                  "anyOf": [
+                                    { "const": "reject", "type": "string" },
+                                    { "const": "coalesce", "type": "string" },
+                                    {
+                                      "const": "replace-oldest",
+                                      "type": "string",
+                                    },
+                                  ],
+                                },
+                              },
+                              "required": ["maxQueuedPerKey", "whenFull"],
+                              "type": "object",
+                            },
                             "queueType": { "minLength": 1, "type": "string" },
                             "result": {
                               "properties": {
@@ -478,6 +533,29 @@ export const CONTRACT = {
                       "required": ["markdown"],
                       "type": "object",
                     },
+                    "keyConcurrency": {
+                      "properties": {
+                        "heartbeatIntervalMs": {
+                          "minimum": 1,
+                          "type": "integer",
+                        },
+                        "heartbeatTtlMs": { "minimum": 1, "type": "integer" },
+                        "key": {
+                          "items": { "minLength": 1, "type": "string" },
+                          "minItems": 1,
+                          "type": "array",
+                        },
+                        "maxActive": { "minimum": 1, "type": "integer" },
+                        "stalePolicy": {
+                          "anyOf": [
+                            { "const": "fail-stale", "type": "string" },
+                            { "const": "block", "type": "string" },
+                          ],
+                        },
+                      },
+                      "required": ["key"],
+                      "type": "object",
+                    },
                     "logs": { "type": "boolean" },
                     "maxDeliver": { "minimum": 1, "type": "integer" },
                     "payload": {
@@ -488,6 +566,18 @@ export const CONTRACT = {
                       "type": "object",
                     },
                     "progress": { "type": "boolean" },
+                    "queue": {
+                      "properties": {
+                        "maxQueuedPerKey": { "minimum": 0, "type": "integer" },
+                        "whenFull": {
+                          "anyOf": [{ "const": "reject", "type": "string" }, {
+                            "const": "coalesce",
+                            "type": "string",
+                          }, { "const": "replace-oldest", "type": "string" }],
+                        },
+                      },
+                      "type": "object",
+                    },
                     "result": {
                       "properties": {
                         "schema": { "minLength": 1, "type": "string" },

package/src/sdk/_generated/core/mod.ts

@@ -8,7 +8,6 @@ export type {
   Service,
   ServiceEventSurface,
   ServiceHandle,
-  ServiceWithDeps,
   TrellisCoreClient,
   TrellisCoreState,
 } from "./client.js";

package/src/sdk/_generated/core/owned_api.ts

@@ -23,7 +23,7 @@ export const OWNED_API = {
       output: schema<Types.TrellisBindingsGetOutput>(
         TrellisBindingsGetResponseSchema,
       ),
-      callerCapabilities: ["service"],
+      callerCapabilities: ["service"] as const,
       errors: ["UnexpectedError", "ValidationError"] as const,
       declaredErrorTypes: ["UnexpectedError", "ValidationError"] as const,
     },
@@ -31,7 +31,7 @@ export const OWNED_API = {
       subject: "rpc.v1.Trellis.Catalog",
       input: schema<Types.TrellisCatalogInput>(TrellisCatalogRequestSchema),
       output: schema<Types.TrellisCatalogOutput>(TrellisCatalogResponseSchema),
-      callerCapabilities: ["trellis.core::catalog.read"],
+      callerCapabilities: ["trellis.core::catalog.read"] as const,
       errors: ["UnexpectedError", "ValidationError"] as const,
       declaredErrorTypes: ["UnexpectedError", "ValidationError"] as const,
     },
@@ -43,7 +43,7 @@ export const OWNED_API = {
       output: schema<Types.TrellisContractGetOutput>(
         TrellisContractGetResponseSchema,
       ),
-      callerCapabilities: ["trellis.core::contract.read"],
+      callerCapabilities: ["trellis.core::contract.read"] as const,
       errors: ["UnexpectedError", "ValidationError"] as const,
       declaredErrorTypes: ["UnexpectedError", "ValidationError"] as const,
     },
@@ -55,7 +55,7 @@ export const OWNED_API = {
       output: schema<Types.TrellisSurfaceStatusOutput>(
         TrellisSurfaceStatusResponseSchema,
       ),
-      callerCapabilities: ["trellis.core::catalog.read"],
+      callerCapabilities: ["trellis.core::catalog.read"] as const,
       errors: ["UnexpectedError", "ValidationError"] as const,
       declaredErrorTypes: ["UnexpectedError", "ValidationError"] as const,
     },

package/src/sdk/_generated/core/schemas.ts

@@ -75,6 +75,38 @@ export const TrellisBindingsGetResponseSchema = {
                           "type": "integer",
                         },
                         "dlq": { "type": "boolean" },
+                        "keyConcurrency": {
+                          "properties": {
+                            "heartbeatIntervalMs": {
+                              "minimum": 1,
+                              "type": "integer",
+                            },
+                            "heartbeatTtlMs": {
+                              "minimum": 1,
+                              "type": "integer",
+                            },
+                            "key": {
+                              "items": { "minLength": 1, "type": "string" },
+                              "minItems": 1,
+                              "type": "array",
+                            },
+                            "maxActive": { "minimum": 1, "type": "integer" },
+                            "stalePolicy": {
+                              "anyOf": [{
+                                "const": "fail-stale",
+                                "type": "string",
+                              }, { "const": "block", "type": "string" }],
+                            },
+                          },
+                          "required": [
+                            "key",
+                            "maxActive",
+                            "heartbeatIntervalMs",
+                            "heartbeatTtlMs",
+                            "stalePolicy",
+                          ],
+                          "type": "object",
+                        },
                         "logs": { "type": "boolean" },
                         "maxDeliver": { "minimum": 1, "type": "integer" },
                         "payload": {
@@ -86,6 +118,23 @@ export const TrellisBindingsGetResponseSchema = {
                         },
                         "progress": { "type": "boolean" },
                         "publishPrefix": { "minLength": 1, "type": "string" },
+                        "queue": {
+                          "properties": {
+                            "maxQueuedPerKey": {
+                              "minimum": 0,
+                              "type": "integer",
+                            },
+                            "whenFull": {
+                              "anyOf": [
+                                { "const": "reject", "type": "string" },
+                                { "const": "coalesce", "type": "string" },
+                                { "const": "replace-oldest", "type": "string" },
+                              ],
+                            },
+                          },
+                          "required": ["maxQueuedPerKey", "whenFull"],
+                          "type": "object",
+                        },
                         "queueType": { "minLength": 1, "type": "string" },
                         "result": {
                           "properties": {
@@ -381,6 +430,26 @@ export const TrellisContractGetResponseSchema = {
                   "required": ["markdown"],
                   "type": "object",
                 },
+                "keyConcurrency": {
+                  "properties": {
+                    "heartbeatIntervalMs": { "minimum": 1, "type": "integer" },
+                    "heartbeatTtlMs": { "minimum": 1, "type": "integer" },
+                    "key": {
+                      "items": { "minLength": 1, "type": "string" },
+                      "minItems": 1,
+                      "type": "array",
+                    },
+                    "maxActive": { "minimum": 1, "type": "integer" },
+                    "stalePolicy": {
+                      "anyOf": [{ "const": "fail-stale", "type": "string" }, {
+                        "const": "block",
+                        "type": "string",
+                      }],
+                    },
+                  },
+                  "required": ["key"],
+                  "type": "object",
+                },
                 "logs": { "type": "boolean" },
                 "maxDeliver": { "minimum": 1, "type": "integer" },
                 "payload": {
@@ -391,6 +460,18 @@ export const TrellisContractGetResponseSchema = {
                   "type": "object",
                 },
                 "progress": { "type": "boolean" },
+                "queue": {
+                  "properties": {
+                    "maxQueuedPerKey": { "minimum": 0, "type": "integer" },
+                    "whenFull": {
+                      "anyOf": [{ "const": "reject", "type": "string" }, {
+                        "const": "coalesce",
+                        "type": "string",
+                      }, { "const": "replace-oldest", "type": "string" }],
+                    },
+                  },
+                  "type": "object",
+                },
                 "result": {
                   "properties": {
                     "schema": { "minLength": 1, "type": "string" },

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

@@ -1,10 +1,18 @@
 // Generated from ./generated/contracts/manifests/trellis.core@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.core@v1" as const;
 export const CONTRACT_DIGEST =
-  "L4HW6uUIxDhK1Kpa_PUxpumoMberMgiCgJTNN5Qvje0" as const;
+  "1vbZgyhBkgKDSkzqvkwItxObBfaLNdysxFBeTT-Ng2c" as const;
 
 export type TrellisBindingsGetInput = { contractId?: string; digest?: string };
 export type TrellisBindingsGetOutput = {
@@ -35,11 +43,22 @@ export type TrellisBindingsGetOutput = {
             consumerName: string;
             defaultDeadlineMs?: number;
             dlq: boolean;
+            keyConcurrency?: {
+              heartbeatIntervalMs: number;
+              heartbeatTtlMs: number;
+              key: Array<string>;
+              maxActive: number;
+              stalePolicy: "fail-stale" | "block";
+            };
             logs: boolean;
             maxDeliver: number;
             payload: { schema: string };
             progress: boolean;
             publishPrefix: string;
+            queue?: {
+              maxQueuedPerKey: number;
+              whenFull: "reject" | "coalesce" | "replace-oldest";
+            };
             queueType: string;
             result?: { schema: string };
             workSubject: string;
@@ -138,10 +157,21 @@ export type TrellisContractGetOutput = {
         defaultDeadlineMs?: number;
         dlq?: boolean;
         docs?: { markdown: string; summary?: string };
+        keyConcurrency?: {
+          heartbeatIntervalMs?: number;
+          heartbeatTtlMs?: number;
+          key: Array<string>;
+          maxActive?: number;
+          stalePolicy?: "fail-stale" | "block";
+        };
         logs?: boolean;
         maxDeliver?: number;
         payload: { schema: string };
         progress?: boolean;
+        queue?: {
+          maxQueuedPerKey?: number;
+          whenFull?: "reject" | "coalesce" | "replace-oldest";
+        };
         result?: { schema: string };
       };
     };
@@ -228,22 +258,56 @@ export interface RpcMap {
   };
 }
 
-export type TrellisBindingsGetHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Trellis.Bindings.Get"
+export type TrellisBindingsGetHandlerError = TrellisErrorInstance;
+export type TrellisBindingsGetHandlerResult = Result<
+  TrellisBindingsGetOutput,
+  TrellisBindingsGetHandlerError
 >;
-export type TrellisCatalogHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Trellis.Catalog"
+export type TrellisBindingsGetHandler = (
+  args: {
+    input: TrellisBindingsGetInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) => TrellisBindingsGetHandlerResult | Promise<TrellisBindingsGetHandlerResult>;
+export type TrellisCatalogHandlerError = TrellisErrorInstance;
+export type TrellisCatalogHandlerResult = Result<
+  TrellisCatalogOutput,
+  TrellisCatalogHandlerError
 >;
-export type TrellisContractGetHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Trellis.Contract.Get"
+export type TrellisCatalogHandler = (
+  args: {
+    input: TrellisCatalogInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) => TrellisCatalogHandlerResult | Promise<TrellisCatalogHandlerResult>;
+export type TrellisContractGetHandlerError = TrellisErrorInstance;
+export type TrellisContractGetHandlerResult = Result<
+  TrellisContractGetOutput,
+  TrellisContractGetHandlerError
 >;
-export type TrellisSurfaceStatusHandler = RpcHandlerFn<
-  typeof API.owned,
-  "Trellis.Surface.Status"
+export type TrellisContractGetHandler = (
+  args: {
+    input: TrellisContractGetInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) => TrellisContractGetHandlerResult | Promise<TrellisContractGetHandlerResult>;
+export type TrellisSurfaceStatusHandlerError = TrellisErrorInstance;
+export type TrellisSurfaceStatusHandlerResult = Result<
+  TrellisSurfaceStatusOutput,
+  TrellisSurfaceStatusHandlerError
 >;
+export type TrellisSurfaceStatusHandler = (
+  args: {
+    input: TrellisSurfaceStatusInput;
+    context: RpcHandlerContext;
+    client: HandlerClient;
+  },
+) =>
+  | TrellisSurfaceStatusHandlerResult
+  | Promise<TrellisSurfaceStatusHandlerResult>;
 
 export interface EventMap {
 }