@michelangelo-ai/rpc 0.10.0 → 0.11.0

package/__tests__/request.test.ts

@@ -1,5 +1,13 @@
+import { create, toBinary } from '@bufbuild/protobuf';
+import { anyPack } from '@bufbuild/protobuf/wkt';
 import { expect, it, vi } from 'vitest';
 
+import { TypedStructSchema } from '../gen/michelangelo/api/typed_struct_pb';
+import {
+  PipelineManifest_Type,
+  PipelineSchema,
+  PipelineType,
+} from '../gen/michelangelo/api/v2/pipeline_pb';
 import { request } from '../request';
 
 vi.mock('../handlers', () => ({
@@ -50,3 +58,96 @@ it('handles arrays containing objects with protobuf internals', async () => {
 
   expect(await request('GetPipelineRun', {} as never)).toEqual({ items: [{ x: 1 }, { x: 2 }] });
 });
+
+it('unpacks a registered Any payload (Pipeline) into a plain object', async () => {
+  const pipeline = create(PipelineSchema, {
+    metadata: { name: 'my-pipeline' },
+    spec: { type: PipelineType.DATA_PREP, commit: { branch: 'main' } },
+  });
+  mockHandler({
+    $typeName: 'michelangelo.api.v2.Revision',
+    spec: {
+      $typeName: 'michelangelo.api.v2.RevisionSpec',
+      revisionId: 'abc',
+      content: {
+        $typeName: 'google.protobuf.Any',
+        typeUrl: 'type.googleapis.com/michelangelo.api.v2.Pipeline',
+        value: toBinary(PipelineSchema, pipeline),
+      },
+    },
+  });
+
+  const result = (await request('GetPipelineRun', {} as never)) as {
+    spec: {
+      content: { metadata: { name: string }; spec: { type: number; commit: { branch: string } } };
+    };
+  };
+
+  expect(result.spec.content.metadata.name).toBe('my-pipeline');
+  expect(result.spec.content.spec.type).toBe(PipelineType.DATA_PREP);
+  expect(result.spec.content.spec.commit.branch).toBe('main');
+  expect(result.spec.content).not.toHaveProperty('$typeName');
+});
+
+it('unpacks a registered Any payload whose own fields contain a nested TypedStruct Any', async () => {
+  // The Pipeline packed into Revision.spec.content (a registry-typed Any) has its own
+  // manifest.content field, which is a TypedStruct. Both must unpack in one pass: toPlainObject
+  // recurses into the decoded Pipeline and finds the inner Any too.
+  const manifestContent = anyPack(
+    TypedStructSchema,
+    create(TypedStructSchema, {
+      typeUrl: 'type.googleapis.com/michelangelo.pipeline.dataprep.Config',
+      value: { source: 'hive' },
+    })
+  );
+  const pipeline = create(PipelineSchema, {
+    metadata: { name: 'my-pipeline' },
+    spec: {
+      type: PipelineType.DATA_PREP,
+      commit: { branch: 'main' },
+      manifest: {
+        type: PipelineManifest_Type.PIPELINE_MANIFEST_TYPE_YAML,
+        content: manifestContent,
+      },
+    },
+  });
+  mockHandler({
+    $typeName: 'michelangelo.api.v2.Revision',
+    spec: {
+      $typeName: 'michelangelo.api.v2.RevisionSpec',
+      revisionId: 'abc',
+      content: {
+        $typeName: 'google.protobuf.Any',
+        typeUrl: 'type.googleapis.com/michelangelo.api.v2.Pipeline',
+        value: toBinary(PipelineSchema, pipeline),
+      },
+    },
+  });
+
+  const result = (await request('GetPipelineRun', {} as never)) as {
+    spec: {
+      content: {
+        spec: { manifest: { content: { typeUrl: string; value: { source: string } } } };
+      };
+    };
+  };
+
+  expect(result.spec.content.spec.manifest.content).toEqual({
+    typeUrl: 'type.googleapis.com/michelangelo.pipeline.dataprep.Config',
+    value: { source: 'hive' },
+  });
+});
+
+it('leaves an unregistered Any payload untouched', async () => {
+  const bytes = new Uint8Array([9, 9]);
+  mockHandler({
+    $typeName: 'google.protobuf.Any',
+    typeUrl: 'type.googleapis.com/unknown.Type',
+    value: bytes,
+  });
+
+  expect(await request('GetPipelineRun', {} as never)).toEqual({
+    typeUrl: 'type.googleapis.com/unknown.Type',
+    value: bytes,
+  });
+});

package/handlers.ts

@@ -36,6 +36,7 @@ async function createHandlers() {
   const services = await getServices();
 
   return {
+    ListCluster: unary(services.ClusterService.listCluster),
     ListDeployment: unary(services.DeploymentService.listDeployment),
     GetDeployment: unary(services.DeploymentService.getDeployment),
     CreateDeployment: (record: Deployment, headers?: Record<string, string>) => {
@@ -45,6 +46,14 @@ async function createHandlers() {
       }
       return services.DeploymentService.createDeployment({ deployment: record }, headers);
     },
+    UpdateDeployment: (record: Deployment, headers?: Record<string, string>) => {
+      const actorName = headers?.['x-user-name'];
+      if (actorName && record.spec) {
+        record.spec.owner = create(UserInfoSchema, { name: actorName });
+      }
+      return services.DeploymentService.updateDeployment({ deployment: record }, headers);
+    },
+    DeleteDeployment: deleteCrd(services.DeploymentService.deleteDeployment),
     ListInferenceServer: unary(services.InferenceServerService.listInferenceServer),
     GetInferenceServer: unary(services.InferenceServerService.getInferenceServer),
     CreateInferenceServer: (record: InferenceServer, headers?: Record<string, string>) =>
@@ -79,6 +88,8 @@ async function createHandlers() {
     ListModel: unary(services.ModelService.listModel),
     GetModel: unary(services.ModelService.getModel),
     ListModelFamily: unary(services.ModelFamilyService.listModelFamily),
+    ListRevision: unary(services.RevisionService.listRevision),
+    GetRevision: unary(services.RevisionService.getRevision),
   } as const;
 }
 

package/package.json

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

package/request.ts

@@ -2,6 +2,7 @@ import { fromBinary, toJson } from '@bufbuild/protobuf';
 
 import { TypedStructSchema } from './gen/michelangelo/api/typed_struct_pb';
 import { getRpcHandlers } from './handlers';
+import { typeRegistry } from './services';
 
 import type { Any } from '@bufbuild/protobuf/wkt';
 import type { OmitTypeName, RpcHandlerType } from './types';
@@ -47,8 +48,8 @@ function toPlainObject(value: unknown): unknown {
   if (value instanceof Uint8Array) return value; // preserve bytes fields (e.g. google.protobuf.Any.value)
   if (Array.isArray(value)) return value.map(toPlainObject);
 
-  const typedStruct = unpackTypedStructAny(value);
-  if (typedStruct) return typedStruct;
+  const unpacked = unpackAny(value);
+  if (unpacked !== undefined) return unpacked;
 
   const result: Record<string, unknown> = {};
   for (const [key, val] of Object.entries(value)) {
@@ -58,16 +59,28 @@ function toPlainObject(value: unknown): unknown {
   return result;
 }
 
-const TYPED_STRUCT_TYPE_URL = `type.googleapis.com/${TypedStructSchema.typeName}`;
+const TYPE_URL_PREFIX = 'type.googleapis.com/';
+const TYPED_STRUCT_TYPE_URL = `${TYPE_URL_PREFIX}${TypedStructSchema.typeName}`;
 
 // google.protobuf.Any fields survive fromJson as { typeUrl, value: Uint8Array } — the binary
-// payload is useless to consumers. When the payload is a michelangelo.api.TypedStruct
-// (e.g. PipelineManifest.content), expand it to { typeUrl, value } where typeUrl names the
-// inner config type and value is its plain JSON. Other Any payloads are left untouched.
-function unpackTypedStructAny(value: object): unknown {
+// payload is useless to consumers.
+//
+// - A michelangelo.api.TypedStruct payload (e.g. PipelineManifest.content) expands to
+//   { typeUrl, value } where typeUrl names the inner config type and value is its plain JSON.
+// - Any other payload whose type is in the RPC type registry (e.g. a Pipeline inside
+//   Revision.spec.content) is decoded and flattened into a plain object shaped exactly like
+//   that message would be if it arrived as a top-level response, so column paths such as
+//   `spec.content.spec.type` read the same values (numeric enums, Timestamp objects) as they
+//   would on the base resource.
+// - Unregistered payloads are left untouched.
+function unpackAny(value: object): unknown {
   if (!('$typeName' in value) || value.$typeName !== 'google.protobuf.Any') return undefined;
   // cast: the $typeName check above identifies this as a google.protobuf.Any message
   const any = value as Any;
-  if (any.typeUrl !== TYPED_STRUCT_TYPE_URL) return undefined;
-  return toJson(TypedStructSchema, fromBinary(TypedStructSchema, any.value));
+  if (any.typeUrl === TYPED_STRUCT_TYPE_URL) {
+    return toJson(TypedStructSchema, fromBinary(TypedStructSchema, any.value));
+  }
+  const schema = typeRegistry.getMessage(any.typeUrl.replace(TYPE_URL_PREFIX, ''));
+  if (!schema) return undefined;
+  return toPlainObject(fromBinary(schema, any.value));
 }

package/services.ts

@@ -8,13 +8,16 @@ import {
 
 import { createFetchTransport } from './create-fetch-transport';
 import { TypedStructSchema } from './gen/michelangelo/api/typed_struct_pb';
+import { ClusterService } from './gen/michelangelo/api/v2/cluster_svc_pb';
 import { DeploymentService } from './gen/michelangelo/api/v2/deployment_svc_pb';
 import { InferenceServerService } from './gen/michelangelo/api/v2/inference_server_svc_pb';
 import { ModelFamilyService } from './gen/michelangelo/api/v2/model_family_svc_pb';
 import { ModelService } from './gen/michelangelo/api/v2/model_svc_pb';
+import { PipelineSchema } from './gen/michelangelo/api/v2/pipeline_pb';
 import { PipelineRunService } from './gen/michelangelo/api/v2/pipeline_run_svc_pb';
 import { PipelineService } from './gen/michelangelo/api/v2/pipeline_svc_pb';
 import { ProjectService } from './gen/michelangelo/api/v2/project_svc_pb';
+import { RevisionService } from './gen/michelangelo/api/v2/revision_svc_pb';
 import { TriggerRunService } from './gen/michelangelo/api/v2/trigger_run_svc_pb';
 import { packAnyFields } from './pack-any-fields';
 import { getRuntimeConfig } from './runtime-config';
@@ -22,12 +25,14 @@ import { getRuntimeConfig } from './runtime-config';
 import type { DescService } from '@bufbuild/protobuf';
 import type { FetchTransport, ServiceClient, Services } from './types';
 
-// These wrapper schemas are registered so criteria that wrap a matchValue in a
-// google.protobuf.Any (e.g. ListOptionsExt filters, packed by packAnyFields) can be
-// JSON-encoded — protobuf-es resolves an Any's typeUrl against this registry to serialize
-// it as a well-known type.
-const typeRegistry = createRegistry(
+// Every message type that can appear inside a google.protobuf.Any on the wire must be
+// registered here — protobuf-es resolves an Any's typeUrl against this registry both when
+// JSON-encoding requests (ListOptionsExt criteria packed by packAnyFields) and when decoding
+// responses (fromJson throws on an unregistered typeUrl). PipelineSchema covers
+// Revision.spec.content for Pipeline revisions.
+export const typeRegistry = createRegistry(
   TypedStructSchema,
+  PipelineSchema,
   StringValueSchema,
   BoolValueSchema,
   Int64ValueSchema,
@@ -80,6 +85,7 @@ async function createServices(): Promise<Services> {
   const transport = createFetchTransport({ baseUrl: apiBaseUrl });
 
   return {
+    ClusterService: createServiceClient(ClusterService, transport),
     DeploymentService: createServiceClient(DeploymentService, transport),
     InferenceServerService: createServiceClient(InferenceServerService, transport),
     ProjectService: createServiceClient(ProjectService, transport),
@@ -88,6 +94,7 @@ async function createServices(): Promise<Services> {
     TriggerRunService: createServiceClient(TriggerRunService, transport),
     ModelService: createServiceClient(ModelService, transport),
     ModelFamilyService: createServiceClient(ModelFamilyService, transport),
+    RevisionService: createServiceClient(RevisionService, transport),
   } as const;
 }
 

package/types.ts

@@ -6,6 +6,7 @@ import type {
   MessageInitShape,
   MessageShape,
 } from '@bufbuild/protobuf';
+import type { ClusterService } from './gen/michelangelo/api/v2/cluster_svc_pb';
 import type { DeploymentService } from './gen/michelangelo/api/v2/deployment_svc_pb';
 import type { InferenceServerService } from './gen/michelangelo/api/v2/inference_server_svc_pb';
 import type { ModelFamilyService } from './gen/michelangelo/api/v2/model_family_svc_pb';
@@ -13,6 +14,7 @@ import type { ModelService } from './gen/michelangelo/api/v2/model_svc_pb';
 import type { PipelineRunService } from './gen/michelangelo/api/v2/pipeline_run_svc_pb';
 import type { PipelineService } from './gen/michelangelo/api/v2/pipeline_svc_pb';
 import type { ProjectService } from './gen/michelangelo/api/v2/project_svc_pb';
+import type { RevisionService } from './gen/michelangelo/api/v2/revision_svc_pb';
 import type { TriggerRunService } from './gen/michelangelo/api/v2/trigger_run_svc_pb';
 import type { getRpcHandlers } from './handlers';
 
@@ -61,6 +63,7 @@ export type ServiceClient<T extends DescService> = {
 };
 
 export type Services = {
+  ClusterService: ServiceClient<typeof ClusterService>;
   DeploymentService: ServiceClient<typeof DeploymentService>;
   InferenceServerService: ServiceClient<typeof InferenceServerService>;
   ProjectService: ServiceClient<typeof ProjectService>;
@@ -69,6 +72,7 @@ export type Services = {
   TriggerRunService: ServiceClient<typeof TriggerRunService>;
   ModelService: ServiceClient<typeof ModelService>;
   ModelFamilyService: ServiceClient<typeof ModelFamilyService>;
+  RevisionService: ServiceClient<typeof RevisionService>;
 };
 
 /**