@michelangelo-ai/rpc 0.4.0 → 0.5.0-rc.2

package/__tests__/handlers.test.ts

@@ -29,7 +29,7 @@ describe('rpc handlers — mutation envelope wrapping', () => {
     const record = { metadata: { name: 'test-run' } };
     await handlers.CreatePipelineRun(record as never);
 
-    expect(createPipelineRun).toHaveBeenCalledWith({ pipelineRun: record });
+    expect(createPipelineRun).toHaveBeenCalledWith({ pipelineRun: record }, undefined);
   });
 
   it('UpdatePipelineRun wraps the bare record in a pipelineRun envelope', async () => {
@@ -37,7 +37,7 @@ describe('rpc handlers — mutation envelope wrapping', () => {
     const record = { metadata: { name: 'updated-run' } };
     await handlers.UpdatePipelineRun(record as never);
 
-    expect(updatePipelineRun).toHaveBeenCalledWith({ pipelineRun: record });
+    expect(updatePipelineRun).toHaveBeenCalledWith({ pipelineRun: record }, undefined);
   });
 
   it('UpdateTriggerRun wraps the bare record in a triggerRun envelope', async () => {
@@ -45,6 +45,23 @@ describe('rpc handlers — mutation envelope wrapping', () => {
     const record = { metadata: { name: 'kill-target' } };
     await handlers.UpdateTriggerRun(record as never);
 
-    expect(updateTriggerRun).toHaveBeenCalledWith({ triggerRun: record });
+    expect(updateTriggerRun).toHaveBeenCalledWith({ triggerRun: record }, undefined);
+  });
+
+  it('CreatePipelineRun stamps spec.actor from x-user-name header', async () => {
+    const handlers = await getRpcHandlers();
+    const record = { metadata: { name: 'run-1' }, spec: { pipeline: { name: 'p1' } } };
+    await handlers.CreatePipelineRun(record as never, { 'x-user-name': 'jane' });
+
+    expect(record.spec).toHaveProperty('actor');
+    expect((record.spec as Record<string, unknown>).actor).toMatchObject({ name: 'jane' });
+  });
+
+  it('CreatePipelineRun leaves spec.actor unset when x-user-name header is absent', async () => {
+    const handlers = await getRpcHandlers();
+    const record = { metadata: { name: 'run-2' }, spec: { pipeline: { name: 'p1' } } };
+    await handlers.CreatePipelineRun(record as never);
+
+    expect((record.spec as Record<string, unknown>).actor).toBeUndefined();
   });
 });

package/create-fetch-transport.ts

@@ -16,10 +16,10 @@ export function createFetchTransport(options: FetchTransportOptions): FetchTrans
   };
 
   return {
-    async callUnary(serviceName, methodName, request) {
+    async callUnary(serviceName, methodName, request, perRequestHeaders) {
       const response = await fetch(`${baseUrl}/${serviceName}/${methodName}`, {
         method: 'POST',
-        headers,
+        headers: perRequestHeaders ? { ...headers, ...perRequestHeaders } : headers,
         body: JSON.stringify(request),
       });
 

package/handlers.ts

@@ -1,3 +1,6 @@
+import { create } from '@bufbuild/protobuf';
+
+import { UserInfoSchema } from './gen/michelangelo/api/v2/user_pb';
 import { getServices } from './services';
 
 import type { PipelineRun } from './gen/michelangelo/api/v2/pipeline_run_pb';
@@ -28,12 +31,17 @@ async function createHandlers() {
     GetPipelineRun: unary(services.PipelineRunService.getPipelineRun),
     ListTriggerRun: unary(services.TriggerRunService.listTriggerRun),
     GetTriggerRun: unary(services.TriggerRunService.getTriggerRun),
-    UpdateTriggerRun: (record: TriggerRun) =>
-      services.TriggerRunService.updateTriggerRun({ triggerRun: record }),
-    CreatePipelineRun: (record: PipelineRun) =>
-      services.PipelineRunService.createPipelineRun({ pipelineRun: record }),
-    UpdatePipelineRun: (record: PipelineRun) =>
-      services.PipelineRunService.updatePipelineRun({ pipelineRun: record }),
+    UpdateTriggerRun: (record: TriggerRun, headers?: Record<string, string>) =>
+      services.TriggerRunService.updateTriggerRun({ triggerRun: record }, headers),
+    CreatePipelineRun: (record: PipelineRun, headers?: Record<string, string>) => {
+      const actorName = headers?.['x-user-name'];
+      if (actorName && record.spec) {
+        record.spec.actor = create(UserInfoSchema, { name: actorName });
+      }
+      return services.PipelineRunService.createPipelineRun({ pipelineRun: record }, headers);
+    },
+    UpdatePipelineRun: (record: PipelineRun, headers?: Record<string, string>) =>
+      services.PipelineRunService.updatePipelineRun({ pipelineRun: record }, headers),
     ListModel: unary(services.ModelService.listModel),
   } as const;
 }

package/package.json

@@ -2,7 +2,7 @@
   "name": "@michelangelo-ai/rpc",
   "license": "Apache-2.0",
   "type": "module",
-  "version": "0.4.0",
+  "version": "0.5.0-rc.2",
   "repository": {
     "type": "git",
     "url": "https://github.com/michelangelo-ai/michelangelo"
@@ -17,7 +17,7 @@
   },
   "dependencies": {
     "@bufbuild/protobuf": "^2.2.5",
-    "@michelangelo-ai/core": "*"
+    "@michelangelo-ai/core": "0.5.0-rc.2"
   },
   "exports": {
     ".": {

package/request.ts

@@ -10,6 +10,7 @@ import type { OmitTypeName, RpcHandlerType } from './types';
  *
  * @param rpcId - The ID of the RPC handler to call.
  * @param args - The arguments to pass to the RPC handler.
+ * @param headers - Optional HTTP headers to send with the request (e.g. user identity).
  * @returns A promise that resolves to the RPC response as a plain object.
  *
  * @example
@@ -21,14 +22,15 @@ import type { OmitTypeName, RpcHandlerType } from './types';
  */
 export async function request<RpcId extends keyof RpcHandlerType>(
   rpcId: RpcId,
-  args: OmitTypeName<Parameters<RpcHandlerType[RpcId]>[0]>
+  args: OmitTypeName<Parameters<RpcHandlerType[RpcId]>[0]>,
+  headers?: Record<string, string>
 ): Promise<OmitTypeName<Awaited<ReturnType<RpcHandlerType[RpcId]>>>> {
   const handlers = await getRpcHandlers();
   // cast: dynamic key lookup on handlers loses the specific RPC signature; we know RpcId is a valid
   // key with matching handler shape
-  const handler = handlers[rpcId] as (a: unknown) => Promise<unknown>;
+  const handler = handlers[rpcId] as (a: unknown, h?: Record<string, string>) => Promise<unknown>;
   // cast: handler returns unknown via dynamic dispatch; RpcId determines the concrete return type
-  const response = (await handler(args)) as Awaited<ReturnType<RpcHandlerType[RpcId]>>;
+  const response = (await handler(args, headers)) as Awaited<ReturnType<RpcHandlerType[RpcId]>>;
   // cast: toPlainObject returns unknown; RpcId determines the proto shape after stripping $typeName
   // fields
   return toPlainObject(response) as OmitTypeName<Awaited<ReturnType<RpcHandlerType[RpcId]>>>;

package/services.ts

@@ -26,15 +26,23 @@ function createServiceClient<T extends DescService>(
   service: T,
   transport: FetchTransport
 ): ServiceClient<T> {
-  const client: Record<string, (request: Record<string, unknown>) => Promise<unknown>> = {};
+  const client: Record<
+    string,
+    (request: Record<string, unknown>, headers?: Record<string, string>) => Promise<unknown>
+  > = {};
 
   for (const method of service.methods) {
     if (method.methodKind !== 'unary') continue;
 
-    client[method.localName] = async (request) => {
+    client[method.localName] = async (request, headers) => {
       const message = create(method.input, request);
       const requestJson = toJson(method.input, message, { registry: typeRegistry });
-      const responseJson = await transport.callUnary(service.typeName, method.name, requestJson);
+      const responseJson = await transport.callUnary(
+        service.typeName,
+        method.name,
+        requestJson,
+        headers
+      );
       return fromJson(method.output, responseJson, { registry: typeRegistry });
     };
   }

package/types.ts

@@ -41,7 +41,12 @@ export interface FetchTransport {
    * Calls a unary RPC through Envoy's grpc_json_transcoder by POSTing JSON to
    * `/{serviceName}/{methodName}` and returning the parsed JSON response.
    */
-  callUnary(serviceName: string, methodName: string, request: unknown): Promise<JsonValue>;
+  callUnary(
+    serviceName: string,
+    methodName: string,
+    request: unknown,
+    headers?: Record<string, string>
+  ): Promise<JsonValue>;
 }
 
 /**
@@ -50,7 +55,7 @@ export interface FetchTransport {
  */
 export type ServiceClient<T extends DescService> = {
   [K in keyof T['method']]: T['method'][K] extends DescMethodUnary<infer I, infer O>
-    ? (request: MessageInitShape<I>) => Promise<MessageShape<O>>
+    ? (request: MessageInitShape<I>, headers?: Record<string, string>) => Promise<MessageShape<O>>
     : never;
 };
 
@@ -85,8 +90,11 @@ export type RpcHandlerType = Awaited<ReturnType<typeof getRpcHandlers>>;
  * // => (args: { projectId: string }) => Promise<Project>
  * ```
  */
-export type ExtractUnaryRpc<T> = T extends (args: Record<string, unknown>) => Promise<infer R>
-  ? (args: Record<string, unknown>) => Promise<R>
+export type ExtractUnaryRpc<T> = T extends (
+  args: Record<string, unknown>,
+  headers?: Record<string, string>
+) => Promise<infer R>
+  ? (args: Record<string, unknown>, headers?: Record<string, string>) => Promise<R>
   : never;
 
 /**