feat: add marketplace tools to retrieve Item Type Definitions

Author: epessina

README.md

@@ -78,7 +78,7 @@ following command:
 npm ci
 ```
 
-Once has finished you will have all the dependencies installed on the project, then you have to prepare an environent
+Once has finished you will have all the dependencies installed on the project, then you have to prepare an environment
 file by copying the default.env file and edit it accordingly.
 
 ```sh

package-lock.json

@@ -13,6 +13,7 @@
     "build": "rimraf mcp-server && tsc --build",
     "coverage": "c8 npm run test",
     "lint": "eslint --ext .ts src",
+    "check:types": "tsc --noEmit",
     "local:test-client-credentials": "npm run build && npx @modelcontextprotocol/[email protected] -e MIA_PLATFORM_CLIENT_ID=\"${MIA_PLATFORM_CLIENT_ID}\" -e MIA_PLATFORM_CLIENT_SECRET=\"${MIA_PLATFORM_CLIENT_SECRET}\" -- node mcp-server start --stdio --server-host 127.0.0.1",
     "local:test": "npm run build && npx @modelcontextprotocol/[email protected] -- node mcp-server start --stdio --server-host 127.0.0.1",
     "start": "npm run build && node mcp-server start",
@@ -30,7 +31,7 @@
   },
   "homepage": "https://github.com/mia-platform/console-mcp-server#readme",
   "dependencies": {
-    "@mia-platform/console-types": "^0.38.11",
+    "@mia-platform/console-types": "^0.39.0",
     "@modelcontextprotocol/sdk": "^1.17.5",
     "commander": "^14.0.0",
     "fastify": "^5.5.0",

package.json

@@ -124,6 +124,7 @@ suite('create service from marketplace plugin', () => {
           'simple-service': inputResources,
         },
       },
+      itemTypeDefinitionRef: { namespace: 'mia-platform', name: 'plugin' },
     }
 
     const output = await servicePayloadFromMarketplaceItem(marketplaceItem, 'simple-service', 'some-description')
@@ -193,6 +194,7 @@ suite('create service from marketplace plugin', () => {
           'simple-service': inputResources,
         },
       },
+      itemTypeDefinitionRef: { namespace: 'mia-platform', name: 'plugin' },
     }
 
     const output = await servicePayloadFromMarketplaceItem(marketplaceItem, 'simple-service', 'some-description')
@@ -330,6 +332,7 @@ suite('create service from marketplace plugin', () => {
           'simple-service': inputResources,
         },
       },
+      itemTypeDefinitionRef: { namespace: 'mia-platform', name: 'plugin' },
     }
 
     const output = await servicePayloadFromMarketplaceItem(marketplaceItem, 'simple-service', 'some-description')
@@ -435,6 +438,7 @@ suite('create service from marketplace template', () => {
           'simple-template': inputResources,
         },
       },
+      itemTypeDefinitionRef: { namespace: 'mia-platform', name: 'template' },
     }
 
     const output = await servicePayloadFromMarketplaceItem(
@@ -527,6 +531,7 @@ suite('create service from marketplace template', () => {
           'simple-template': inputResources,
         },
       },
+      itemTypeDefinitionRef: { namespace: 'mia-platform', name: 'template' },
     }
 
     const output = await servicePayloadFromMarketplaceItem(

src/apis/client.test.ts

@@ -18,6 +18,7 @@ import path from 'node:path'
 import { UndiciHeaders } from 'undici/types/dispatcher'
 import {
   CatalogItemRelease,
+  CatalogItemTypeDefinition,
   CatalogVersionedItem,
   ConfigMaps,
   ConfigServiceSecrets,
@@ -140,6 +141,8 @@ export interface IAPIClient {
   listMarketplaceItems(tenantID?: string, type?: string, search?: string): Promise<Record<string, unknown>[]>
   marketplaceItemVersions(tenantID: string, itemID: string): Promise<CatalogItemRelease[]>
   marketplaceItemInfo(tenantID: string, itemID: string, version?: string): Promise<CatalogVersionedItem>
+  listMarketplaceItemTypeDefinitions(namespace?: string, name?: string, displayName?: string): Promise<CatalogItemTypeDefinition[]>
+  marketplaceItemTypeDefinitionInfo (tenantID: string, name: string): Promise<CatalogItemTypeDefinition>
   // #endregion
 }
 
@@ -367,6 +370,14 @@ export class APIClient implements IAPIClient {
     return this.#marketplaceClient.marketplaceItemInfo(tenantID, itemID, version)
   }
 
+  async listMarketplaceItemTypeDefinitions (namespace?: string, name?: string, displayName?: string): Promise<CatalogItemTypeDefinition[]> {
+    return this.#marketplaceClient.listMarketplaceItemTypeDefinitions(namespace, name, displayName)
+  }
+
+  async marketplaceItemTypeDefinitionInfo (tenantID: string, name: string): Promise<CatalogItemTypeDefinition> {
+    return this.#marketplaceClient.marketplaceItemTypeDefinitionInfo(tenantID, name)
+  }
+
   async #resourceToCreateFromMarketplaceItem (
     project: IProject,
     marketplaceItem: CatalogVersionedItem,
@@ -543,6 +554,8 @@ export interface APIClientMockFunctions {
   listMarketplaceItemsMockFn?: (tenantID?: string, type?: string, search?: string) => Promise<Record<string, unknown>[]>
   marketplaceItemVersionsMockFn?: (tenantID: string, itemID: string) => Promise<CatalogItemRelease[]>
   marketplaceItemInfoMockFn?: (tenantID: string, itemID: string, version?: string) => Promise<CatalogVersionedItem>
+  listMarketplaceItemTypeDefinitionsMockFn?: (namespace?: string, name?: string, displayName?: string) => Promise<CatalogItemTypeDefinition[]>
+  marketplaceItemTypeDefinitionInfoMockFn?: (tenantID: string, name: string) => Promise<CatalogItemTypeDefinition>
   // #endregion
 }
 
@@ -770,6 +783,22 @@ export class APIClientMock implements IAPIClient {
     return this.mocks.marketplaceItemInfoMockFn(tenantID, itemID, version)
   }
 
+  async listMarketplaceItemTypeDefinitions (namespace?: string, name?: string, displayName?: string): Promise<CatalogItemTypeDefinition[]> {
+    if (!this.mocks.listMarketplaceItemTypeDefinitionsMockFn) {
+      throw new Error('listMarketplaceItemTypeDefinitionsMockFn not mocked')
+    }
+
+    return this.mocks.listMarketplaceItemTypeDefinitionsMockFn(namespace, name, displayName)
+  }
+
+  async marketplaceItemTypeDefinitionInfo (tenantID: string, name: string): Promise<CatalogItemTypeDefinition> {
+    if (!this.mocks.marketplaceItemTypeDefinitionInfoMockFn) {
+      throw new Error('marketplaceItemTypeDefinitionInfoMockFn not mocked')
+    }
+
+    return this.mocks.marketplaceItemTypeDefinitionInfoMockFn(tenantID, name)
+  }
+
   // #endregion
 }
 

src/apis/client.ts

@@ -89,6 +89,7 @@ export class HTTPClient {
     maxPage = 10,
   ): Promise<T[]> {
     const url = new URL(path, this.baseURL)
+    // TODO: should it be `perPage`?
     params.set('per_page', '200')
 
     const results: T[] = []

src/apis/http-client/index.ts

@@ -16,11 +16,13 @@
 import { beforeEach, suite, test, TestContext } from 'node:test'
 import { MockAgent, setGlobalDispatcher } from 'undici'
 
+import { CatalogItemTypeDefinition } from '@mia-platform/console-types'
 import { HTTPClient } from './http-client'
 import { internalEndpoint, MarketplaceClient, MarketplaceClientInternal } from './marketplaceClient'
 
 const tenantID = 'tenantID'
 const itemID = 'itemid'
+const itdName = 'itdName'
 const search = 'item1'
 const type = 'example'
 const version = '1.0.1'
@@ -34,6 +36,48 @@ const publicItems = [
   { itemId: 'item-id-2', name: 'item2', tenantId: 'public' },
 ]
 
+const itemTypeDefinitions: CatalogItemTypeDefinition[] = [
+  {
+    apiVersion: 'software-catalog.mia-platform.eu/v1',
+    kind: 'item-type-definition',
+    metadata: {
+      namespace: { scope: 'tenant', id: 'mia-platform' },
+      displayName: 'Plugin ITD',
+      name: 'plugin',
+      visibility: { scope: 'console' },
+    },
+    spec: {
+      isVersioningSupported: true,
+      type: 'plugin',
+      scope: 'tenant',
+      validation: {
+        mechanism: 'json-schema',
+        schema: { type: 'object' },
+      },
+    },
+    __v: 1,
+  },
+  {
+    apiVersion: 'software-catalog.mia-platform.eu/v1',
+    kind: 'item-type-definition',
+    metadata: {
+      namespace: { scope: 'tenant', id: 'my-company' },
+      displayName: 'Custom Workload ITD',
+      name: 'custom-workload',
+      visibility: { scope: 'tenant', ids: [ 'my-company' ] },
+    },
+    spec: {
+      type: 'custom-workload',
+      scope: 'tenant',
+      validation: {
+        mechanism: 'json-schema',
+        schema: { type: 'object' },
+      },
+    },
+    __v: 1,
+  },
+]
+
 suite('Marketplace Internal Client', () => {
   const client = MarketplaceClientInternal('', '')
   let agent: MockAgent
@@ -167,6 +211,62 @@ suite('Marketplace Internal Client', () => {
     }).reply(500, { error: 'Internal Server Error' })
     await t.assert.rejects(async () => await client.marketplaceItemInfo(tenantID, itemID, version), { name: 'Error' })
   })
+
+  test('list marketplace Item Type Definitions', async (t: TestContext) => {
+    agent.get(internalEndpoint).intercept({
+      path: '/api/marketplace/item-type-definitions',
+      method: 'GET',
+      query: {
+        perPage: 200,
+        per_page: 200,
+        page: 1,
+      },
+    }).reply(200, itemTypeDefinitions)
+    t.assert.deepEqual(await client.listMarketplaceItemTypeDefinitions(), itemTypeDefinitions)
+
+    agent.get(internalEndpoint).intercept({
+      path: '/api/marketplace/item-type-definitions',
+      method: 'GET',
+      query: {
+        perPage: 200,
+        per_page: 200,
+        page: 1,
+        namespace: 'mia-platform,my-company',
+        name: 'plugin,custom-workload',
+        displayName: 'Plugin,Custom Workload',
+      },
+    }).reply(200, itemTypeDefinitions)
+    t.assert.deepEqual(await client.listMarketplaceItemTypeDefinitions('mia-platform,my-company', 'plugin,custom-workload', 'Plugin,Custom Workload'), itemTypeDefinitions)
+  })
+
+  test('list marketplace Item Type Definitions must throw if the API call fails', async (t: TestContext) => {
+    agent.get(internalEndpoint).intercept({
+      path: '/api/marketplace/item-type-definitions',
+      method: 'GET',
+      query: {
+        perPage: 200,
+        per_page: 200,
+        page: 1,
+      },
+    }).reply(500, { error: 'Internal Server Error' })
+    await t.assert.rejects(async () => await client.listMarketplaceItemTypeDefinitions(), { name: 'Error' })
+  })
+
+  test('marketplace Item Type Definition info', async (t: TestContext) => {
+    agent.get(internalEndpoint).intercept({
+      path: `/api/tenants/${tenantID}/marketplace/item-type-definitions/${itdName}`,
+      method: 'GET',
+    }).reply(200, itemTypeDefinitions.at(0))
+    t.assert.deepEqual(await client.marketplaceItemTypeDefinitionInfo(tenantID, itdName), itemTypeDefinitions.at(0))
+  })
+
+  test('marketplace Item Type Definitions info must throw if the API call fails', async (t: TestContext) => {
+    agent.get(internalEndpoint).intercept({
+      path: `/api/tenants/${tenantID}/marketplace/item-type-definitions/${itdName}`,
+      method: 'GET',
+    }).reply(500, { error: 'Internal Server Error' })
+    await t.assert.rejects(async () => await client.marketplaceItemTypeDefinitionInfo(tenantID, itdName), { name: 'Error' })
+  })
 })
 
 suite('Marketplace Client', () => {
@@ -279,4 +379,60 @@ suite('Marketplace Client', () => {
     }).reply(500, { error: 'Internal Server Error' })
     await t.assert.rejects(async () => await client.marketplaceItemInfo(tenantID, itemID, version), { name: 'Error' })
   })
+
+  test('list marketplace Item Type Definitions', async (t: TestContext) => {
+    agent.get(mockedEndpoint).intercept({
+      path: '/api/marketplace/item-type-definitions',
+      method: 'GET',
+      query: {
+        perPage: 200,
+        per_page: 200,
+        page: 1,
+      },
+    }).reply(200, itemTypeDefinitions)
+    t.assert.deepEqual(await client.listMarketplaceItemTypeDefinitions(), itemTypeDefinitions)
+
+    agent.get(mockedEndpoint).intercept({
+      path: '/api/marketplace/item-type-definitions',
+      method: 'GET',
+      query: {
+        perPage: 200,
+        per_page: 200,
+        page: 1,
+        namespace: 'mia-platform,my-company',
+        name: 'plugin,custom-workload',
+        displayName: 'Plugin,Custom Workload',
+      },
+    }).reply(200, itemTypeDefinitions)
+    t.assert.deepEqual(await client.listMarketplaceItemTypeDefinitions('mia-platform,my-company', 'plugin,custom-workload', 'Plugin,Custom Workload'), itemTypeDefinitions)
+  })
+
+  test('list marketplace Item Type Definitions must throw if the API call fails', async (t: TestContext) => {
+    agent.get(mockedEndpoint).intercept({
+      path: '/api/marketplace/item-type-definitions',
+      method: 'GET',
+      query: {
+        perPage: 200,
+        per_page: 200,
+        page: 1,
+      },
+    }).reply(500, { error: 'Internal Server Error' })
+    await t.assert.rejects(async () => await client.listMarketplaceItemTypeDefinitions(), { name: 'Error' })
+  })
+
+  test('marketplace Item Type Definition info', async (t: TestContext) => {
+    agent.get(mockedEndpoint).intercept({
+      path: `/api/tenants/${tenantID}/marketplace/item-type-definitions/${itdName}`,
+      method: 'GET',
+    }).reply(200, itemTypeDefinitions.at(0))
+    t.assert.deepEqual(await client.marketplaceItemTypeDefinitionInfo(tenantID, itdName), itemTypeDefinitions.at(0))
+  })
+
+  test('marketplace Item Type Definitions info must throw if the API call fails', async (t: TestContext) => {
+    agent.get(mockedEndpoint).intercept({
+      path: `/api/tenants/${tenantID}/marketplace/item-type-definitions/${itdName}`,
+      method: 'GET',
+    }).reply(500, { error: 'Internal Server Error' })
+    await t.assert.rejects(async () => await client.marketplaceItemTypeDefinitionInfo(tenantID, itdName), { name: 'Error' })
+  })
 })

src/apis/marketplaceClient.test.ts

@@ -16,7 +16,7 @@
 import { UndiciHeaders } from 'undici/types/dispatcher'
 
 import { HTTPClient } from './http-client'
-import { CatalogItemRelease, CatalogVersionedItem } from '@mia-platform/console-types'
+import { CatalogItemRelease, CatalogItemTypeDefinition, CatalogVersionedItem } from '@mia-platform/console-types'
 
 export const internalEndpoint = process.env.MARKETPLACE_INTERNAL_ENDPOINT || 'http://internal.local:3000'
 
@@ -73,6 +73,21 @@ export class MarketplaceClient {
     return this.#client.get<CatalogVersionedItem>(this.#itemInfoPath(tenantID, itemID, itemVersion))
   }
 
+  async listMarketplaceItemTypeDefinitions (namespace?: string, name?: string, displayName?: string): Promise<CatalogItemTypeDefinition[]> {
+    const params = new URLSearchParams({
+      perPage: '200',
+      ...namespace && { namespace },
+      ...name && { name },
+      ...displayName && { displayName },
+    })
+
+    return this.#client.getPaginated<CatalogItemTypeDefinition>(this.#itemTypeDefinitionsPath(), params)
+  }
+
+  async marketplaceItemTypeDefinitionInfo (tenantID: string, name: string): Promise<CatalogItemTypeDefinition> {
+    return this.#client.get<CatalogItemTypeDefinition>(this.#itemTypeDefinitionInfoPath(tenantID, name))
+  }
+
   #marketplacePath (): string {
     return '/api/marketplace/'
   }
@@ -84,4 +99,12 @@ export class MarketplaceClient {
   #itemInfoPath (tenantID: string, itemID: string, version: string): string {
     return `/api/tenants/${tenantID}/marketplace/items/${itemID}/versions/${version}`
   }
+
+  #itemTypeDefinitionsPath (): string {
+    return '/api/marketplace/item-type-definitions'
+  }
+
+  #itemTypeDefinitionInfoPath (tenantID: string, name: string): string {
+    return `/api/tenants/${tenantID}/marketplace/item-type-definitions/${name}`
+  }
 }