@platformatic/control 2.30.1-alpha.1 → 2.30.2

package/index.d.ts

@@ -10,11 +10,69 @@ declare namespace control {
     ws: WebSocket;
   }
 
+  interface Runtime {
+    pid: number,
+    cwd: string,
+    argv: string[],
+    uptimeSeconds: number,
+    execPath: string,
+    nodeVersion: string,
+    projectDir: string,
+    packageName: string | null,
+    packageVersion: string | null,
+    url: string | null,
+    platformaticVersion: string
+  }
+
+  interface RuntimeServices {
+    entrypoint: string,
+    production: boolean,
+    services: ({
+      id: string;
+      type: string;
+      status: string;
+      version: string;
+      localUrl: string;
+      entrypoint: boolean;
+      dependencies: {
+        id: string;
+        url: string;
+        local: boolean;
+      }[];
+    } | {
+      id: string;
+      status: string;
+    })[]
+  }
+
+  interface MetricValue {
+    value: number,
+    labels: {
+      type?: string,
+      space?: string,
+      version?: string,
+      major?: number,
+      minor?: number,
+      patch?: number,
+      le?: number | string,
+      kind?: string,
+      serviceId: string
+    }
+  }
+  
+  interface Metric {
+    help: string,
+    name: string,
+    type: string,
+    values: MetricValue[],
+    aggregator: string
+  }
+
   export class RuntimeApiClient {
-    getMatchingRuntime(opts: { pid?: string; name?: string }): Promise<unknown>;
-    getRuntimes(): Promise<unknown[]>;
-    getRuntimeMetadata(pid: number): Promise<unknown>;
-    getRuntimeServices(pid: number): Promise<unknown>;
+    getMatchingRuntime(options?: { pid?: string; name?: string }): Promise<Runtime>;
+    getRuntimes(): Promise<Runtime[]>;
+    getRuntimeMetadata(pid: number): Promise<Runtime>;
+    getRuntimeServices(pid: number): Promise<RuntimeServices>;
     getRuntimeConfig(pid: number): Promise<void>;
     getRuntimeServiceConfig(pid: number, serviceId?: string): Promise<void>;
     getRuntimeEnv(pid: number): Promise<void>;
@@ -22,10 +80,10 @@ declare namespace control {
     reloadRuntime(pid: number, options?: object): Promise<ChildProcess>;
     restartRuntime(pid: number): Promise<void>;
     stopRuntime(pid: number): Promise<void>;
-    getRuntimeMetrics(
+    getRuntimeMetrics<T extends { format?: "text" | "json" }>(
       pid: number,
-      options?: { format?: "text" | "json" }
-    ): Promise<unknown>;
+      options?: T
+    ): Promise<T extends { format: "text" } ? string : Metric[]>;
     getRuntimeLiveMetricsStream(pid: number): WebSocketStream;
     getRuntimeLiveLogsStream(
       pid: number,

package/index.test-d.ts

@@ -1,10 +1,30 @@
 import { expectError, expectType } from 'tsd'
-import { errors, RuntimeApiClient } from '.'
+import { errors, Metric, Runtime, RuntimeApiClient, RuntimeServices } from '.'
 import { FastifyError } from '@fastify/error'
 
 // RuntimeApiClient
+let runtime = {} as Runtime
+let service = {} as RuntimeServices
+let metric = {} as Metric
 const api = new RuntimeApiClient()
-expectType<Promise<unknown[]>>(api.getRuntimes())
+expectType<Promise<Runtime>>(api.getMatchingRuntime())
+expectType<Promise<Metric[]>>(api.getRuntimeMetrics(runtime.pid))
+expectType<Promise<Metric[]>>(api.getRuntimeMetrics(runtime.pid, {}))
+expectType<Promise<Metric[]>>(api.getRuntimeMetrics(runtime.pid, { format: 'json' }))
+expectType<Promise<string>>(api.getRuntimeMetrics(runtime.pid, { format: 'text' }))
+expectType<Promise<Runtime[]>>(api.getRuntimes())
+expectType<string[]>(runtime.argv)
+expectType<number>(runtime.uptimeSeconds)
+expectType<string | null>(runtime.packageVersion)
+expectType<Promise<{
+  entrypoint: string,
+  production: boolean,
+  services: RuntimeServices['services']
+}>>(api.getRuntimeServices(45))
+expectType<string>(service.services[0].id)
+expectType<string>(service.services[0].status)
+expectType<string>(metric.aggregator)
+expectType<string>(metric.values[0].labels.serviceId)
 expectType<Promise<void>>(api.close())
 
 // errors

package/lib/runtime-api-client.js

@@ -17,7 +17,7 @@ class RuntimeApiClient {
   #undiciClients = new Map()
   #webSockets = new Set()
 
-  async getMatchingRuntime (opts) {
+  async getMatchingRuntime (opts = {}) {
     const runtimes = await this.getRuntimes()
 
     let runtime = null

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/control",
-  "version": "2.30.1-alpha.1",
+  "version": "2.30.2",
   "description": "Platformatic Control",
   "main": "index.js",
   "bin": {
@@ -25,8 +25,8 @@
     "split2": "^4.2.0",
     "tsd": "^0.31.0",
     "typescript": "^5.5.4",
-    "@platformatic/service": "2.30.1-alpha.1",
-    "@platformatic/runtime": "2.30.1-alpha.1"
+    "@platformatic/service": "2.30.2",
+    "@platformatic/runtime": "2.30.2"
   },
   "dependencies": {
     "@fastify/error": "^4.0.0",
@@ -37,7 +37,7 @@
     "table": "^6.8.1",
     "undici": "^7.0.0",
     "ws": "^8.16.0",
-    "@platformatic/utils": "2.30.1-alpha.1"
+    "@platformatic/utils": "2.30.2"
   },
   "scripts": {
     "test": "pnpm run lint && pnpm run unit && tsd",