@daocloud-proto/mcamel-rabbitmq 0.4.0-13 → 0.4.0-130

package/cluster.pb.ts

@@ -4,7 +4,8 @@
 * This file is a generated Typescript file for GRPC Gateway, DO NOT MODIFY
 */
 
-import * as fm from "../../v1alpha1/ts_out/api"
+import * as CommonCommon from "./common.pb"
+import * as fm from "./fetch.pb"
 
 export enum GetClusterListRespGetClusterListDataClusterPhase {
   CLUSTER_PHASE_UNSPECIFIED = "CLUSTER_PHASE_UNSPECIFIED",
@@ -25,7 +26,8 @@ export type GetClusterListRespGetClusterListData = {
 }
 
 export type GetClusterListResp = {
-  data?: GetClusterListRespGetClusterListData[]
+  items?: GetClusterListRespGetClusterListData[]
+  pagination?: CommonCommon.Pagination
 }
 
 export type GetClusterNamespaceListReq = {
@@ -33,14 +35,15 @@ export type GetClusterNamespaceListReq = {
 }
 
 export type GetClusterNamespaceListResp = {
-  data?: string[]
+  items?: string[]
+  pagination?: CommonCommon.Pagination
 }
 
 export class Cluster {
   static GetClusterList(req: GetClusterListReq, initReq?: fm.InitReq): Promise<GetClusterListResp> {
-    return fm.fetchReq<GetClusterListReq, GetClusterListResp>(`/apis/mcamel.io/v1alpha1/clusters?${fm.renderURLSearchParams(req, [])}`, {...initReq, method: "GET"})
+    return fm.fetchReq<GetClusterListReq, GetClusterListResp>(`/apis/mcamel.io/rabbitmq/v1alpha1/clusters?${fm.renderURLSearchParams(req, [])}`, {...initReq, method: "GET"})
   }
   static GetClusterNamespaceList(req: GetClusterNamespaceListReq, initReq?: fm.InitReq): Promise<GetClusterNamespaceListResp> {
-    return fm.fetchReq<GetClusterNamespaceListReq, GetClusterNamespaceListResp>(`/apis/mcamel.io/v1alpha1/${req["cluster"]}/namespaces?${fm.renderURLSearchParams(req, ["cluster"])}`, {...initReq, method: "GET"})
+    return fm.fetchReq<GetClusterNamespaceListReq, GetClusterNamespaceListResp>(`/apis/mcamel.io/rabbitmq/v1alpha1/${req["cluster"]}/namespaces?${fm.renderURLSearchParams(req, ["cluster"])}`, {...initReq, method: "GET"})
   }
 }

package/common.pb.ts

@@ -0,0 +1,24 @@
+/* eslint-disable */
+// @ts-nocheck
+/*
+* This file is a generated Typescript file for GRPC Gateway, DO NOT MODIFY
+*/
+
+export enum PageInfoReqSortDir {
+  ASC = "ASC",
+  DESC = "DESC",
+}
+
+export type Pagination = {
+  total?: number
+  page?: number
+  pageSize?: number
+  pages?: number
+}
+
+export type PageInfoReq = {
+  page?: number
+  pageSize?: number
+  sortDir?: PageInfoReqSortDir
+  sortBy?: string
+}

package/fetch.pb.ts

@@ -0,0 +1,232 @@
+/* eslint-disable */
+// @ts-nocheck
+/*
+* This file is a generated Typescript file for GRPC Gateway, DO NOT MODIFY
+*/
+
+export interface InitReq extends RequestInit {
+  pathPrefix?: string
+}
+
+export function fetchReq<I, O>(path: string, init?: InitReq): Promise<O> {
+  const {pathPrefix, ...req} = init || {}
+
+  const url = pathPrefix ? `${pathPrefix}${path}` : path
+
+  return fetch(url, req).then(r => r.json().then((body: O) => {
+    if (!r.ok) { throw body; }
+    return body;
+  })) as Promise<O>
+}
+
+// NotifyStreamEntityArrival is a callback that will be called on streaming entity arrival
+export type NotifyStreamEntityArrival<T> = (resp: T) => void
+
+/**
+ * fetchStreamingRequest is able to handle grpc-gateway server side streaming call
+ * it takes NotifyStreamEntityArrival that lets users respond to entity arrival during the call
+ * all entities will be returned as an array after the call finishes.
+ **/
+export async function fetchStreamingRequest<S, R>(path: string, callback?: NotifyStreamEntityArrival<R>, init?: InitReq) {
+  const {pathPrefix, ...req} = init || {}
+  const url = pathPrefix ?`${pathPrefix}${path}` : path
+  const result = await fetch(url, req)
+  // needs to use the .ok to check the status of HTTP status code
+  // http other than 200 will not throw an error, instead the .ok will become false.
+  // see https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch#
+  if (!result.ok) {
+    const resp = await result.json()
+    const errMsg = resp.error && resp.error.message ? resp.error.message : ""
+    throw new Error(errMsg)
+  }
+
+  if (!result.body) {
+    throw new Error("response doesnt have a body")
+  }
+
+  await result.body
+    .pipeThrough(new TextDecoderStream())
+    .pipeThrough<R>(getNewLineDelimitedJSONDecodingStream<R>())
+    .pipeTo(getNotifyEntityArrivalSink((e: R) => {
+      if (callback) {
+        callback(e)
+      }
+    }))
+
+  // wait for the streaming to finish and return the success respond
+  return
+}
+
+/**
+ * JSONStringStreamController represents the transform controller that's able to transform the incoming
+ * new line delimited json content stream into entities and able to push the entity to the down stream
+ */
+interface JSONStringStreamController<T> extends TransformStreamDefaultController {
+  buf?: string
+  pos?: number
+  enqueue: (s: T) => void
+}
+
+/**
+ * getNewLineDelimitedJSONDecodingStream returns a TransformStream that's able to handle new line delimited json stream content into parsed entities
+ */
+function getNewLineDelimitedJSONDecodingStream<T>(): TransformStream<string, T> {
+  return new TransformStream({
+    start(controller: JSONStringStreamController<T>) {
+      controller.buf = ''
+      controller.pos = 0
+    },
+
+    transform(chunk: string, controller: JSONStringStreamController<T>) {
+      if (controller.buf === undefined) {
+        controller.buf = ''
+      }
+      if (controller.pos === undefined) {
+        controller.pos = 0
+      }
+      controller.buf += chunk
+      while (controller.pos < controller.buf.length) {
+        if (controller.buf[controller.pos] === '\n') {
+          const line = controller.buf.substring(0, controller.pos)
+          const response = JSON.parse(line)
+          controller.enqueue(response.result)
+          controller.buf = controller.buf.substring(controller.pos + 1)
+          controller.pos = 0
+        } else {
+          ++controller.pos
+        }
+      }
+    }
+  })
+
+}
+
+/**
+ * getNotifyEntityArrivalSink takes the NotifyStreamEntityArrival callback and return
+ * a sink that will call the callback on entity arrival
+ * @param notifyCallback
+ */
+function getNotifyEntityArrivalSink<T>(notifyCallback: NotifyStreamEntityArrival<T>) {
+  return new WritableStream<T>({
+    write(entity: T) {
+      notifyCallback(entity)
+    }
+  })
+}
+
+type Primitive = string | boolean | number;
+type RequestPayload = Record<string, unknown>;
+type FlattenedRequestPayload = Record<string, Primitive | Array<Primitive>>;
+
+/**
+ * Checks if given value is a plain object
+ * Logic copied and adapted from below source: 
+ * https://github.com/char0n/ramda-adjunct/blob/master/src/isPlainObj.js
+ * @param  {unknown} value
+ * @return {boolean}
+ */
+function isPlainObject(value: unknown): boolean {
+  const isObject =
+    Object.prototype.toString.call(value).slice(8, -1) === "Object";
+  const isObjLike = value !== null && isObject;
+
+  if (!isObjLike || !isObject) {
+    return false;
+  }
+
+  const proto = Object.getPrototypeOf(value);
+
+  const hasObjectConstructor =
+    typeof proto === "object" &&
+    proto.constructor === Object.prototype.constructor;
+
+  return hasObjectConstructor;
+}
+
+/**
+ * Checks if given value is of a primitive type
+ * @param  {unknown} value
+ * @return {boolean}
+ */
+function isPrimitive(value: unknown): boolean {
+  return ["string", "number", "boolean"].some(t => typeof value === t);
+}
+
+/**
+ * Checks if given primitive is zero-value
+ * @param  {Primitive} value
+ * @return {boolean}
+ */
+function isZeroValuePrimitive(value: Primitive): boolean {
+  return value === false || value === 0 || value === "";
+}
+
+/**
+ * Flattens a deeply nested request payload and returns an object
+ * with only primitive values and non-empty array of primitive values
+ * as per https://github.com/googleapis/googleapis/blob/master/google/api/http.proto
+ * @param  {RequestPayload} requestPayload
+ * @param  {String} path
+ * @return {FlattenedRequestPayload>}
+ */
+function flattenRequestPayload<T extends RequestPayload>(
+  requestPayload: T,
+  path: string = ""
+): FlattenedRequestPayload {
+  return Object.keys(requestPayload).reduce(
+    (acc: T, key: string): T => {
+      const value = requestPayload[key];
+      const newPath = path ? [path, key].join(".") : key;
+
+      const isNonEmptyPrimitiveArray =
+        Array.isArray(value) &&
+        value.every(v => isPrimitive(v)) &&
+        value.length > 0;
+
+      const isNonZeroValuePrimitive =
+        isPrimitive(value) && !isZeroValuePrimitive(value as Primitive);
+
+      let objectToMerge = {};
+
+      if (isPlainObject(value)) {
+        objectToMerge = flattenRequestPayload(value as RequestPayload, newPath);
+      } else if (isNonZeroValuePrimitive || isNonEmptyPrimitiveArray) {
+        objectToMerge = { [newPath]: value };
+      }
+
+      return { ...acc, ...objectToMerge };
+    },
+    {} as T
+  ) as FlattenedRequestPayload;
+}
+
+/**
+ * Renders a deeply nested request payload into a string of URL search
+ * parameters by first flattening the request payload and then removing keys
+ * which are already present in the URL path.
+ * @param  {RequestPayload} requestPayload
+ * @param  {string[]} urlPathParams
+ * @return {string}
+ */
+export function renderURLSearchParams<T extends RequestPayload>(
+  requestPayload: T,
+  urlPathParams: string[] = []
+): string {
+  const flattenedRequestPayload = flattenRequestPayload(requestPayload);
+
+  const urlSearchParams = Object.keys(flattenedRequestPayload).reduce(
+    (acc: string[][], key: string): string[][] => {
+      // key should not be present in the url path as a parameter
+      const value = flattenedRequestPayload[key];
+      if (urlPathParams.find(f => f === key)) {
+        return acc;
+      }
+      return Array.isArray(value)
+        ? [...acc, ...value.map(m => [key, m.toString()])]
+        : (acc = [...acc, [key, value.toString()]]);
+    },
+    [] as string[][]
+  );
+
+  return new URLSearchParams(urlSearchParams).toString();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name":"@daocloud-proto/mcamel-rabbitmq",
-  "version":"0.4.0-13",
+  "version":"0.4.0-130",
   "description": "",
   "main": "index.js",
   "scripts": {

package/rabbitmq.pb.ts

@@ -4,7 +4,28 @@
 * This file is a generated Typescript file for GRPC Gateway, DO NOT MODIFY
 */
 
-import * as fm from "../../v1alpha1/ts_out/api"
+import * as CommonCommon from "./common.pb"
+import * as fm from "./fetch.pb"
+
+type Absent<T, K extends keyof T> = { [k in Exclude<keyof T, K>]?: undefined };
+type OneOf<T> =
+  | { [k in keyof T]?: undefined }
+  | (
+    keyof T extends infer K ?
+      (K extends string & keyof T ? { [k in K]: T[K] } & Absent<T, K>
+        : never)
+    : never);
+
+export enum Status {
+  Failed = "Failed",
+  Running = "Running",
+  Creating = "Creating",
+}
+
+export enum GetRabbitMqListReqSortDir {
+  ASC = "ASC",
+  DESC = "DESC",
+}
 
 export enum CreateRabbitMqReqServiceType {
   ClusterIP = "ClusterIP",
@@ -19,7 +40,9 @@ export enum GetRabbitMqParamRespSelectSelectType {
 
 export type GetRabbitMqListReq = {
   page?: number
-  size?: number
+  pageSize?: number
+  sortDir?: GetRabbitMqListReqSortDir
+  sortBy?: string
   searchKey?: string
 }
 
@@ -42,7 +65,6 @@ export type CreateRabbitMqReq = {
   describe?: string
   version?: string
   replicas?: number
-  resource?: string
   storageClassName?: string
   storageCapacity?: string
   defaultUser?: string
@@ -50,32 +72,63 @@ export type CreateRabbitMqReq = {
   serviceType?: CreateRabbitMqReqServiceType
   serviceAnnotations?: {[key: string]: string}
   ports?: CreateRabbitMqReqPorts[]
+  cpuRequest?: string
+  cpuLimit?: string
+  memoryRequest?: string
+  memoryLimit?: string
 }
 
-export type UpdateRabbitMqReq = {
+export type UpdateRabbitMqConfReq = {
   cluster?: string
   namespace?: string
   name?: string
   defaultUser?: string
   defaultPass?: string
-  resource?: string
+}
+
+export type UpdateRabbitMqParamsReq = {
+  cluster?: string
+  namespace?: string
+  name?: string
   replicas?: number
   storageCapacity?: string
   serviceType?: CreateRabbitMqReqServiceType
   serviceAnnotations?: {[key: string]: string}
   describe?: string
   ports?: CreateRabbitMqReqPorts[]
+  cpuRequest?: string
+  cpuLimit?: string
+  memoryRequest?: string
+  memoryLimit?: string
 }
 
-export type UpdateRabbitMqResp = {
+export type UpdateRabbitMqParamsResp = {
   message?: string
 }
 
-export type GetRabbitMqParamRespSelectData = {
-  data?: {[key: string]: string}
+export type UpdateRabbitMqConfResp = {
+  message?: string
+}
+
+export type GetRabbitMqParamRespSelectDataStringValue = {
   value?: string
 }
 
+export type GetRabbitMqParamRespSelectDataResourceValue = {
+  cpuRequest?: number
+  cpuLimit?: number
+  memoryRequest?: number
+  memoryLimit?: number
+}
+
+
+type BaseGetRabbitMqParamRespSelectData = {
+  data?: {[key: string]: string}
+}
+
+export type GetRabbitMqParamRespSelectData = BaseGetRabbitMqParamRespSelectData
+  & OneOf<{ sValue: GetRabbitMqParamRespSelectDataStringValue; rValue: GetRabbitMqParamRespSelectDataResourceValue }>
+
 export type GetRabbitMqParamRespSelect = {
   selectType?: GetRabbitMqParamRespSelectSelectType
   data?: GetRabbitMqParamRespSelectData[]
@@ -103,7 +156,8 @@ export type GetRabbitMqOperatorVersionListRespGetRabbitMqOperatorVersionListData
 }
 
 export type GetRabbitMqOperatorVersionListResp = {
-  data?: GetRabbitMqOperatorVersionListRespGetRabbitMqOperatorVersionListData[]
+  items?: GetRabbitMqOperatorVersionListRespGetRabbitMqOperatorVersionListData[]
+  pagination?: CommonCommon.Pagination
 }
 
 export type DeleteRabbitMqReq = {
@@ -132,7 +186,7 @@ export type GetRabbitMqNodeListReq = {
 
 export type GetRabbitMqNodeListRespData = {
   podName?: string
-  status?: string
+  status?: Status
   nodeName?: string
   ip?: string
   restart?: number
@@ -142,13 +196,11 @@ export type GetRabbitMqNodeListRespData = {
 }
 
 export type GetRabbitMqNodeListResp = {
-  data?: GetRabbitMqNodeListRespData[]
+  items?: GetRabbitMqNodeListRespData[]
+  pagination?: CommonCommon.Pagination
 }
 
 export type GetRabbitMqGrafanaAddrReq = {
-  cluster?: string
-  namespace?: string
-  name?: string
 }
 
 export type GetRabbitMqGrafanaAddrResp = {
@@ -166,169 +218,65 @@ export type GetRabbitMqResp = {
 }
 
 export type GetRabbitMqListResp = {
-  data?: RabbitmqClusterList
+  items?: RabbitmqClusterItem[]
+  pagination?: CommonCommon.Pagination
 }
 
 export type RabbitmqClusterItemExtend = {
-  atLeastOneEndpointAvailable?: boolean
+  status?: Status
   podsAreReadyNum?: number
   webManagerAddr?: string
   clusterIPs?: string[]
 }
 
-export type RabbitmqClusterListMetadata = {
-  remainingItemCount?: number
-}
-
-export type RabbitmqClusterList = {
-  metadata?: RabbitmqClusterListMetadata
-  items?: RabbitmqClusterItem[]
-}
-
 export type RabbitmqClusterItemMetadata = {
   annotations?: {[key: string]: string}
-  creationTimestamp?: string
-  finalizers?: string[]
-  generation?: number
-  name?: string
-  namespace?: string
-  resourceVersion?: string
-  uid?: string
-}
-
-export type RabbitmqClusterItemSpecOverride = {
-}
-
-export type RabbitmqClusterItemSpecPersistence = {
-  storage?: string
-  storageClassName?: string
-}
-
-export type RabbitmqClusterItemSpecRabbitmq = {
-  additionalConfig?: string
-  additionalPlugins?: string[]
-}
-
-export type RabbitmqClusterItemSpecResourcesLimits = {
-  cpu?: string
-  memory?: string
-}
-
-export type RabbitmqClusterItemSpecResourcesRequests = {
-  cpu?: string
-  memory?: string
-}
-
-export type RabbitmqClusterItemSpecResources = {
-  limits?: RabbitmqClusterItemSpecResourcesLimits
-  requests?: RabbitmqClusterItemSpecResourcesRequests
-}
-
-export type RabbitmqClusterItemSpecSecretBackend = {
-}
-
-export type RabbitmqClusterItemSpecServiceAnnotations = {
-  asd?: string
-}
-
-export type RabbitmqClusterItemSpecService = {
-  annotations?: RabbitmqClusterItemSpecServiceAnnotations
-  type?: string
-}
-
-export type RabbitmqClusterItemSpecTls = {
-}
-
-export type RabbitmqClusterItemSpec = {
-  image?: string
-  override?: RabbitmqClusterItemSpecOverride
-  persistence?: RabbitmqClusterItemSpecPersistence
-  rabbitmq?: RabbitmqClusterItemSpecRabbitmq
-  replicas?: number
-  resources?: RabbitmqClusterItemSpecResources
-  secretBackend?: RabbitmqClusterItemSpecSecretBackend
-  service?: RabbitmqClusterItemSpecService
-  terminationGracePeriodSeconds?: number
-  tls?: RabbitmqClusterItemSpecTls
-}
-
-export type RabbitmqClusterItemStatusBinding = {
-  name?: string
-}
-
-export type RabbitmqClusterItemStatusConditions = {
-  lastTransitionTime?: string
-  reason?: string
-  status?: string
-  type?: string
-}
-
-export type RabbitmqClusterItemStatusDefaultUserSecretReferenceKeys = {
-  password?: string
-  username?: string
-}
-
-export type RabbitmqClusterItemStatusDefaultUserSecretReference = {
-  keys?: RabbitmqClusterItemStatusDefaultUserSecretReferenceKeys
+  creationTimestamp?: number
   name?: string
   namespace?: string
 }
 
-export type RabbitmqClusterItemStatusDefaultUserServiceReference = {
-  name?: string
-  namespace?: string
-}
-
-export type RabbitmqClusterItemStatusDefaultUser = {
-  secretReference?: RabbitmqClusterItemStatusDefaultUserSecretReference
-  serviceReference?: RabbitmqClusterItemStatusDefaultUserServiceReference
-}
-
-export type RabbitmqClusterItemStatus = {
-  binding?: RabbitmqClusterItemStatusBinding
-  conditions?: RabbitmqClusterItemStatusConditions[]
-  defaultUser?: RabbitmqClusterItemStatusDefaultUser
-  observedGeneration?: number
-}
-
 export type RabbitmqClusterItem = {
   apiVersion?: string
   kind?: string
   metadata?: RabbitmqClusterItemMetadata
-  spec?: RabbitmqClusterItemSpec
-  status?: RabbitmqClusterItemStatus
+  spec?: CreateRabbitMqReq
+  status?: Status
   extend?: RabbitmqClusterItemExtend
 }
 
 export class RabbitMq {
   static GetRabbitMqList(req: GetRabbitMqListReq, initReq?: fm.InitReq): Promise<GetRabbitMqListResp> {
-    return fm.fetchReq<GetRabbitMqListReq, GetRabbitMqListResp>(`/apis/mcamel.io/v1alpha1/rabbitmqs?${fm.renderURLSearchParams(req, [])}`, {...initReq, method: "GET"})
+    return fm.fetchReq<GetRabbitMqListReq, GetRabbitMqListResp>(`/apis/mcamel.io/rabbitmq/v1alpha1/rabbitmqs?${fm.renderURLSearchParams(req, [])}`, {...initReq, method: "GET"})
   }
   static GetRabbitMqOperatorVersionList(req: GetRabbitMqOperatorVersionListReq, initReq?: fm.InitReq): Promise<GetRabbitMqOperatorVersionListResp> {
-    return fm.fetchReq<GetRabbitMqOperatorVersionListReq, GetRabbitMqOperatorVersionListResp>(`/apis/mcamel.io/v1alpha1/rabbitmq-operator/${req["cluster"]}/versions?${fm.renderURLSearchParams(req, ["cluster"])}`, {...initReq, method: "GET"})
+    return fm.fetchReq<GetRabbitMqOperatorVersionListReq, GetRabbitMqOperatorVersionListResp>(`/apis/mcamel.io/rabbitmq/v1alpha1/rabbitmq-operator/${req["cluster"]}/versions?${fm.renderURLSearchParams(req, ["cluster"])}`, {...initReq, method: "GET"})
   }
   static GetRabbitMq(req: GetRabbitMqReq, initReq?: fm.InitReq): Promise<GetRabbitMqResp> {
-    return fm.fetchReq<GetRabbitMqReq, GetRabbitMqResp>(`/apis/mcamel.io/v1alpha1/rabbitmq/${req["cluster"]}/${req["namespace"]}/${req["name"]}?${fm.renderURLSearchParams(req, ["cluster", "namespace", "name"])}`, {...initReq, method: "GET"})
+    return fm.fetchReq<GetRabbitMqReq, GetRabbitMqResp>(`/apis/mcamel.io/rabbitmq/v1alpha1/rabbitmq/${req["cluster"]}/${req["namespace"]}/${req["name"]}?${fm.renderURLSearchParams(req, ["cluster", "namespace", "name"])}`, {...initReq, method: "GET"})
   }
   static GetRabbitMqParam(req: GetRabbitMqParamReq, initReq?: fm.InitReq): Promise<GetRabbitMqParamResp> {
-    return fm.fetchReq<GetRabbitMqParamReq, GetRabbitMqParamResp>(`/apis/mcamel.io/v1alpha1/rabbitmq-params/${req["cluster"]}?${fm.renderURLSearchParams(req, ["cluster"])}`, {...initReq, method: "GET"})
+    return fm.fetchReq<GetRabbitMqParamReq, GetRabbitMqParamResp>(`/apis/mcamel.io/rabbitmq/v1alpha1/rabbitmq-params/${req["cluster"]}?${fm.renderURLSearchParams(req, ["cluster"])}`, {...initReq, method: "GET"})
   }
   static GetRabbitMqNodeList(req: GetRabbitMqNodeListReq, initReq?: fm.InitReq): Promise<GetRabbitMqNodeListResp> {
-    return fm.fetchReq<GetRabbitMqNodeListReq, GetRabbitMqNodeListResp>(`/apis/mcamel.io/v1alpha1/rabbitmq/nodes/${req["cluster"]}/${req["namespace"]}/${req["name"]}?${fm.renderURLSearchParams(req, ["cluster", "namespace", "name"])}`, {...initReq, method: "GET"})
+    return fm.fetchReq<GetRabbitMqNodeListReq, GetRabbitMqNodeListResp>(`/apis/mcamel.io/rabbitmq/v1alpha1/rabbitmq/nodes/${req["cluster"]}/${req["namespace"]}/${req["name"]}?${fm.renderURLSearchParams(req, ["cluster", "namespace", "name"])}`, {...initReq, method: "GET"})
   }
   static GetRabbitMqGrafanaAddr(req: GetRabbitMqGrafanaAddrReq, initReq?: fm.InitReq): Promise<GetRabbitMqGrafanaAddrResp> {
-    return fm.fetchReq<GetRabbitMqGrafanaAddrReq, GetRabbitMqGrafanaAddrResp>(`/apis/mcamel.io/v1alpha1/rabbitmq/grafana/${req["cluster"]}/${req["namespace"]}/${req["name"]}?${fm.renderURLSearchParams(req, ["cluster", "namespace", "name"])}`, {...initReq, method: "GET"})
+    return fm.fetchReq<GetRabbitMqGrafanaAddrReq, GetRabbitMqGrafanaAddrResp>(`/apis/mcamel.io/rabbitmq/v1alpha1/rabbitmq/grafana?${fm.renderURLSearchParams(req, [])}`, {...initReq, method: "GET"})
   }
   static CreateRabbitMq(req: CreateRabbitMqReq, initReq?: fm.InitReq): Promise<CreateRabbitMqResp> {
-    return fm.fetchReq<CreateRabbitMqReq, CreateRabbitMqResp>(`/apis/mcamel.io/v1alpha1/rabbitmq`, {...initReq, method: "POST", body: JSON.stringify(req)})
+    return fm.fetchReq<CreateRabbitMqReq, CreateRabbitMqResp>(`/apis/mcamel.io/rabbitmq/v1alpha1/rabbitmq`, {...initReq, method: "POST", body: JSON.stringify(req)})
+  }
+  static UpdateRabbitMqConf(req: UpdateRabbitMqConfReq, initReq?: fm.InitReq): Promise<UpdateRabbitMqConfResp> {
+    return fm.fetchReq<UpdateRabbitMqConfReq, UpdateRabbitMqConfResp>(`/apis/mcamel.io/rabbitmq/v1alpha1/rabbitmq/${req["cluster"]}/${req["namespace"]}/${req["name"]}/conf`, {...initReq, method: "PUT", body: JSON.stringify(req)})
   }
-  static UpdateRabbitMq(req: UpdateRabbitMqReq, initReq?: fm.InitReq): Promise<UpdateRabbitMqResp> {
-    return fm.fetchReq<UpdateRabbitMqReq, UpdateRabbitMqResp>(`/apis/mcamel.io/v1alpha1/rabbitmq/${req["cluster"]}/${req["namespace"]}/${req["name"]}`, {...initReq, method: "PATCH", body: JSON.stringify(req)})
+  static UpdateRabbitMqParams(req: UpdateRabbitMqParamsReq, initReq?: fm.InitReq): Promise<UpdateRabbitMqParamsResp> {
+    return fm.fetchReq<UpdateRabbitMqParamsReq, UpdateRabbitMqParamsResp>(`/apis/mcamel.io/rabbitmq/v1alpha1/rabbitmq/${req["cluster"]}/${req["namespace"]}/${req["name"]}/params`, {...initReq, method: "PUT", body: JSON.stringify(req)})
   }
   static DeleteRabbitMq(req: DeleteRabbitMqReq, initReq?: fm.InitReq): Promise<DeleteRabbitMqResp> {
-    return fm.fetchReq<DeleteRabbitMqReq, DeleteRabbitMqResp>(`/apis/mcamel.io/v1alpha1/rabbitmq/${req["cluster"]}/${req["namespace"]}/${req["name"]}`, {...initReq, method: "DELETE"})
+    return fm.fetchReq<DeleteRabbitMqReq, DeleteRabbitMqResp>(`/apis/mcamel.io/rabbitmq/v1alpha1/rabbitmq/${req["cluster"]}/${req["namespace"]}/${req["name"]}`, {...initReq, method: "DELETE"})
   }
   static DeleteRabbitMqs(req: DeleteRabbitMqsReq, initReq?: fm.InitReq): Promise<DeleteRabbitMqsResp> {
-    return fm.fetchReq<DeleteRabbitMqsReq, DeleteRabbitMqsResp>(`/apis/mcamel.io/v1alpha1/rabbitmqs`, {...initReq, method: "POST", body: JSON.stringify(req)})
+    return fm.fetchReq<DeleteRabbitMqsReq, DeleteRabbitMqsResp>(`/apis/mcamel.io/rabbitmq/v1alpha1/rabbitmqs`, {...initReq, method: "POST", body: JSON.stringify(req)})
   }
 }

package/version.pb.ts

@@ -4,7 +4,7 @@
 * This file is a generated Typescript file for GRPC Gateway, DO NOT MODIFY
 */
 
-import * as fm from "../../v1alpha1/ts_out/api"
+import * as fm from "./fetch.pb"
 export type CommonReply = {
   code?: number
   msg?: string
@@ -22,6 +22,6 @@ export type Empty = {
 
 export class Version {
   static Get(req: Empty, initReq?: fm.InitReq): Promise<GetVersionReply> {
-    return fm.fetchReq<Empty, GetVersionReply>(`/apis/mcamel.io/v1alpha1/rabbitmq/version?${fm.renderURLSearchParams(req, [])}`, {...initReq, method: "GET"})
+    return fm.fetchReq<Empty, GetVersionReply>(`/apis/mcamel.io/rabbitmq/v1alpha1/rabbitmq/version?${fm.renderURLSearchParams(req, [])}`, {...initReq, method: "GET"})
   }
 }