@qlever-llc/trellis 0.10.7 → 0.10.9

package/script/server/service.js

@@ -10,7 +10,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _StoreHandle_nc, _TrellisService_instances, _TrellisService_server, _TrellisService_handlerTrellis, _TrellisService_operationTransfer, _TrellisService_stopHealthPublishing, _TrellisService_managedJobWorkers, _TrellisService_waitPromise, _TrellisService_stopPromise, _TrellisService_createBoundEventFacade, _TrellisService_createHandleFacade, _TrellisService_createBoundHandleFacade, _TrellisService_operation;
+var _StoreHandle_nc, _TrellisService_instances, _TrellisService_server, _TrellisService_handlerTrellis, _TrellisService_operationTransfer, _TrellisService_stopHealthPublishing, _TrellisService_managedJobWorkers, _TrellisService_waitPromise, _TrellisService_stopPromise, _TrellisService_createBoundHealth, _TrellisService_createBoundEventFacade, _TrellisService_createHandleFacade, _TrellisService_createBoundHandleFacade, _TrellisService_operation;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TrellisService = exports.StoreHandle = void 0;
 exports.createConnectedService = createConnectedService;
@@ -1223,7 +1223,7 @@ class TrellisService {
             kv: this.kv,
             store: this.store,
             jobs: createBoundJobsFacade({ jobs: this.jobs, deps }),
-            health: this.health,
+            health: __classPrivateFieldGet(this, _TrellisService_instances, "m", _TrellisService_createBoundHealth).call(this, deps),
             handle: __classPrivateFieldGet(this, _TrellisService_instances, "m", _TrellisService_createBoundHandleFacade).call(this, deps),
             connection: this.connection,
             createTransfer: (args) => this.createTransfer(args),
@@ -1388,7 +1388,31 @@ class TrellisService {
     }
 }
 exports.TrellisService = TrellisService;
-_TrellisService_server = new WeakMap(), _TrellisService_handlerTrellis = new WeakMap(), _TrellisService_operationTransfer = new WeakMap(), _TrellisService_stopHealthPublishing = new WeakMap(), _TrellisService_managedJobWorkers = new WeakMap(), _TrellisService_waitPromise = new WeakMap(), _TrellisService_stopPromise = new WeakMap(), _TrellisService_instances = new WeakSet(), _TrellisService_createBoundEventFacade = function _TrellisService_createBoundEventFacade(deps) {
+_TrellisService_server = new WeakMap(), _TrellisService_handlerTrellis = new WeakMap(), _TrellisService_operationTransfer = new WeakMap(), _TrellisService_stopHealthPublishing = new WeakMap(), _TrellisService_managedJobWorkers = new WeakMap(), _TrellisService_waitPromise = new WeakMap(), _TrellisService_stopPromise = new WeakMap(), _TrellisService_instances = new WeakSet(), _TrellisService_createBoundHealth = function _TrellisService_createBoundHealth(deps) {
+    const health = this.health;
+    return {
+        serviceName: health.serviceName,
+        kind: health.kind,
+        instanceId: health.instanceId,
+        contractId: health.contractId,
+        contractDigest: health.contractDigest,
+        startedAt: health.startedAt,
+        publishIntervalMs: health.publishIntervalMs,
+        setInfo(info) {
+            if (typeof info !== "function") {
+                health.setInfo(info);
+                return;
+            }
+            health.setInfo(() => info({ deps }));
+        },
+        add(name, check) {
+            return health.add(name, () => check({ deps }));
+        },
+        checks: () => health.checks(),
+        response: () => health.response(),
+        heartbeat: () => health.heartbeat(),
+    };
+}, _TrellisService_createBoundEventFacade = function _TrellisService_createBoundEventFacade(deps) {
     const event = {};
     const source = this.event;
     for (const [groupName, leaves] of Object.entries(source)) {

package/src/auth/protocol.ts

@@ -173,6 +173,14 @@ export type DeploymentAuthorityCapability = StaticDecode<
   typeof DeploymentAuthorityCapabilitySchema
 >;
 
+export const DeploymentAuthorityCapabilityDirectionSchema = Type.Union([
+  Type.Literal("creates"),
+  Type.Literal("given"),
+]);
+export type DeploymentAuthorityCapabilityDirection = StaticDecode<
+  typeof DeploymentAuthorityCapabilityDirectionSchema
+>;
+
 export const DeploymentAuthorityResourceSchema = Type.Object({
   kind: DeploymentAuthorityResourceKindSchema,
   alias: Type.String({ minLength: 1 }),
@@ -254,6 +262,50 @@ export type DeploymentResourceBinding = StaticDecode<
   typeof DeploymentResourceBindingSchema
 >;
 
+export const MaterializedAuthoritySurfaceGrantSchema = Type.Object({
+  kind: Type.Literal("surface"),
+  contractId: Type.String({ minLength: 1 }),
+  surfaceKind: DeploymentAuthoritySurfaceKindSchema,
+  name: Type.String({ minLength: 1 }),
+  action: Type.Optional(DeploymentAuthoritySurfaceActionSchema),
+});
+
+export const MaterializedAuthorityCapabilityGrantSchema = Type.Object({
+  kind: Type.Literal("capability"),
+  capability: DeploymentAuthorityCapabilitySchema,
+});
+
+export const MaterializedAuthorityNatsGrantSourceSchema = Type.Union([
+  Type.Literal("owned-surface"),
+  Type.Literal("used-surface"),
+  Type.Literal("resource-binding"),
+  Type.Literal("platform-service"),
+  Type.Literal("transfer"),
+]);
+
+export const MaterializedAuthorityNatsGrantSchema = Type.Object({
+  kind: Type.Literal("nats"),
+  direction: Type.Union([Type.Literal("publish"), Type.Literal("subscribe")]),
+  subject: Type.String({ minLength: 1 }),
+  surface: Type.Optional(Type.Object({
+    contractId: Type.String({ minLength: 1 }),
+    kind: DeploymentAuthoritySurfaceKindSchema,
+    name: Type.String({ minLength: 1 }),
+    action: Type.Optional(DeploymentAuthoritySurfaceActionSchema),
+  })),
+  requiredCapabilities: Type.Array(Type.String({ minLength: 1 })),
+  grantSource: MaterializedAuthorityNatsGrantSourceSchema,
+});
+
+export const MaterializedAuthorityGrantSchema = Type.Union([
+  MaterializedAuthorityCapabilityGrantSchema,
+  MaterializedAuthoritySurfaceGrantSchema,
+  MaterializedAuthorityNatsGrantSchema,
+]);
+export type MaterializedAuthorityGrant = StaticDecode<
+  typeof MaterializedAuthorityGrantSchema
+>;
+
 export const DeploymentAuthorityMaterializationSchema = Type.Object({
   deploymentId: Type.String({ minLength: 1 }),
   desiredVersion: Type.String({ minLength: 1 }),
@@ -263,7 +315,7 @@ export const DeploymentAuthorityMaterializationSchema = Type.Object({
     Type.Literal("failed"),
   ]),
   resourceBindings: Type.Array(DeploymentResourceBindingSchema),
-  grants: Type.Array(OpenObjectSchema),
+  grants: Type.Array(MaterializedAuthorityGrantSchema),
   reconciledAt: Type.Union([IsoDateStringSchema, Type.Null()]),
   error: Type.Optional(Type.String({ minLength: 1 })),
 });
@@ -1615,6 +1667,7 @@ export const AuthUsersAccountFlowCreateResponseSchema = Type.Object({
 });
 
 export const CapabilityDefinitionSchema = Type.Object({
+  deploymentId: Type.Optional(Type.String({ minLength: 1 })),
   key: Type.String({ minLength: 1 }),
   displayName: Type.String({ minLength: 1 }),
   description: Type.String({ minLength: 1 }),
@@ -1623,6 +1676,7 @@ export const CapabilityDefinitionSchema = Type.Object({
   contractId: Type.Optional(Type.String({ minLength: 1 })),
   contractDigest: Type.Optional(DigestSchema),
   contractDisplayName: Type.Optional(Type.String({ minLength: 1 })),
+  direction: Type.Optional(DeploymentAuthorityCapabilityDirectionSchema),
 });
 
 export const AuthCapabilitiesListSchema = Type.Object({

package/src/contract_support/mod.ts

@@ -68,6 +68,8 @@ import {
 } from "./protocol.js";
 
 export {
+  buildCursorPage,
+  buildPageResponse,
   type ContractEventConsumerEvent,
   ContractEventConsumerEventSchema,
   type ContractEventConsumerGroup,
@@ -83,6 +85,13 @@ export {
   ContractStateSchema,
   ContractStateStoreSchema,
   ContractStoreResourceSchema,
+  type CursorPage,
+  type CursorPageInfo,
+  CursorPageInfoSchema,
+  CursorPageSchema,
+  type CursorQuery,
+  type CursorQueryOptions,
+  CursorQuerySchema,
   type EventConsumerResourceBinding,
   EventConsumerResourceBindingSchema,
   type EventHeader,
@@ -96,6 +105,9 @@ export {
   JobsResourceBindingSchema,
   type KvResourceBinding,
   KvResourceBindingSchema,
+  normalizeCursorQuery,
+  type NormalizedCursorQuery,
+  normalizePageQuery,
   type PageRequest,
   PageRequestSchema,
   type PageResponse,

package/src/contract_support/protocol.ts

@@ -280,3 +280,140 @@ export type PageResponse<TEntry> = {
   limit: number;
   nextOffset?: number;
 };
+
+/**
+ * Validates and normalizes an offset pagination query.
+ *
+ * Ensures `offset` and `limit` are non-negative integers within bounds. Throws
+ * `RangeError` on invalid input.
+ */
+export function normalizePageQuery(
+  query: PageRequest,
+  maxLimit: number = Number.MAX_SAFE_INTEGER,
+): Required<PageRequest> {
+  if (!Number.isInteger(query.limit) || query.limit < 0) {
+    throw new RangeError("list limit must be a non-negative integer");
+  }
+  if (query.limit > maxLimit) {
+    throw new RangeError(`list limit must be <= ${maxLimit}`);
+  }
+  const offset = query.offset ?? 0;
+  if (!Number.isInteger(offset) || offset < 0) {
+    throw new RangeError("list offset must be a non-negative integer");
+  }
+  return { offset, limit: query.limit };
+}
+
+/**
+ * Builds a {@link PageResponse} from a pre-sliced offset page.
+ *
+ * @param entries - The entries for the current page, already sliced by the caller.
+ * @param totalCount - Total number of matching entries before slicing.
+ * @param query - The original pagination query used to produce the page.
+ * @param maxLimit - Optional maximum limit accepted by the endpoint.
+ */
+export function buildPageResponse<T>(
+  entries: T[],
+  totalCount: number,
+  query: PageRequest,
+  maxLimit?: number,
+): PageResponse<T> {
+  const { offset, limit } = normalizePageQuery(query, maxLimit);
+  return {
+    entries,
+    count: totalCount,
+    offset,
+    limit,
+    nextOffset: limit <= 0 || offset + limit >= totalCount
+      ? undefined
+      : offset + limit,
+  };
+}
+
+/** Schema for a cursor pagination query. */
+export const CursorQuerySchema = Type.Object({
+  cursor: Type.Optional(Type.String({ minLength: 1 })),
+  limit: Type.Optional(Type.Integer({ minimum: 0 })),
+});
+
+/** Cursor pagination query. */
+export type CursorQuery = Static<typeof CursorQuerySchema>;
+
+/** Schema for cursor pagination response metadata. */
+export const CursorPageInfoSchema = Type.Object({
+  nextCursor: Type.Optional(Type.String({ minLength: 1 })),
+});
+
+/** Cursor pagination response metadata. */
+export type CursorPageInfo = Static<typeof CursorPageInfoSchema>;
+
+/** Create a schema for a cursor page response with typed items. */
+export function CursorPageSchema<TItem extends TSchema>(item: TItem) {
+  return Type.Object({
+    items: Type.Array(item, { default: [] }),
+    page: CursorPageInfoSchema,
+  });
+}
+
+/** Cursor pagination response with typed items. */
+export type CursorPage<TItem> = {
+  items: TItem[];
+  page: CursorPageInfo;
+};
+
+/** Options for normalizing a cursor pagination query. */
+export type CursorQueryOptions = {
+  /** Limit used when the query does not specify one. Defaults to `100`. */
+  defaultLimit?: number;
+  /** Maximum accepted limit. Defaults to `500`. */
+  maxLimit?: number;
+};
+
+/** Cursor query after defaults and validation have been applied. */
+export type NormalizedCursorQuery = {
+  cursor?: string;
+  limit: number;
+};
+
+/**
+ * Validates and normalizes a cursor pagination query.
+ *
+ * Defaults `limit` to `100`, rejects limits above `500` unless `maxLimit` is
+ * overridden, and preserves a non-empty optional cursor.
+ */
+export function normalizeCursorQuery(
+  query: CursorQuery,
+  options: CursorQueryOptions = {},
+): NormalizedCursorQuery {
+  const maxLimit = options.maxLimit ?? 500;
+  const limit = query.limit ?? options.defaultLimit ?? 100;
+  if (!Number.isInteger(limit) || limit < 0) {
+    throw new RangeError("list limit must be a non-negative integer");
+  }
+  if (limit > maxLimit) {
+    throw new RangeError(`list limit must be <= ${maxLimit}`);
+  }
+  if (query.cursor === undefined) {
+    return { limit };
+  }
+  if (query.cursor.length === 0) {
+    throw new RangeError("list cursor must be a non-empty string");
+  }
+  return { cursor: query.cursor, limit };
+}
+
+/**
+ * Builds a {@link CursorPage} from items and an optional next cursor.
+ *
+ * @param items - The items for the current page.
+ * @param nextCursor - Cursor clients can use to request the next page.
+ */
+export function buildCursorPage<T>(
+  items: T[],
+  nextCursor?: string,
+): CursorPage<T> {
+  return {
+    items,
+    page: nextCursor === undefined ? {} : { nextCursor },
+  };
+}

package/src/index.ts

@@ -57,12 +57,24 @@ export {
 } from "./health.js";
 export { defineError } from "./contract_support/mod.js";
 export {
+  buildCursorPage,
+  buildPageResponse,
+  CursorPageInfoSchema,
+  CursorPageSchema,
+  CursorQuerySchema,
+  normalizeCursorQuery,
+  normalizePageQuery,
   PageRequestSchema,
   PageResponseSchema,
 } from "./contract_support/mod.js";
 export type {
+  CursorPage,
+  CursorPageInfo,
+  CursorQuery,
+  CursorQueryOptions,
   ErrorClass,
   InferRuntimeRpcError,
+  NormalizedCursorQuery,
   PageRequest,
   PageResponse,
   RpcErrorClass,