refactor to @signalk/server-api (#970)

godind · web-flow · commit 571161012b04 · 2026-02-17T22:02:54.000-05:00
diff --git a/package.json b/package.json
@@ -63,12 +63,12 @@
     "@angular/compiler-cli": "21.1.4",
     "@angular/language-service": "21.1.4",
     "@types/canvas-gauges": "^2.1.8",
+    "@types/d3": "^7.4.3",
     "@types/jasmine": "~3.6.0",
     "@types/jasminewd2": "^2.0.9",
     "@types/js-quantities": "^1.6.6",
     "@types/lodash-es": "^4.17.9",
     "@types/node": "^24.1.0",
-    "@types/d3": "^7.4.3",
     "angular-eslint": "21.2.0",
     "codelyzer": "^6.0.0",
     "eslint": "^9.29.0",
@@ -101,6 +101,7 @@
     "@angular/router": "21.1.4",
     "@aziham/chartjs-plugin-streaming": "^3.5.1",
     "@godind/ng-canvas-gauges": "^6.2.1",
+    "@signalk/server-api": "^2.22.0",
     "@zakj/no-sleep": "^0.13.5",
     "chart.js": "^4.5.1",
     "chartjs-adapter-date-fns": "^3.0.0",
@@ -117,10 +118,9 @@
     "prismjs": "^1.30.0",
     "rxjs": "^7.8.2",
     "screenfull": "^6.0.2",
+    "sk-ais-status-plugin": "^1.0.0",
     "steelseries": "^2.0.9",
     "tslib": "^2.6.2",
-    "zone.js": "^0.15.1",
-    "@signalk/server-api": "^2.7.2",
-    "sk-ais-status-plugin": "^1.0.0"
+    "zone.js": "^0.15.1"
   }
 }
diff --git a/src/app/core/services/signalk-history.service.spec.ts b/src/app/core/services/signalk-history.service.spec.ts
@@ -48,6 +48,41 @@ describe('SignalkHistoryService', () => {
     httpMock.expectNone(() => true);
   });
 
+  it('should pass duration to history values endpoint', async () => {
+    connectionStub.serverServiceEndpoint$.next({
+      operation: 2,
+      message: 'Connected',
+      serverDescription: 'Signal K',
+      httpServiceUrl: 'http://localhost:3000/signalk/v1/api/',
+      WsServiceUrl: 'ws://localhost:3000/signalk/v1/stream'
+    });
+
+    const promise = service.getValues({
+      paths: 'navigation.speedThroughWater:average',
+      duration: 'PT10M',
+      resolution: 1
+    });
+
+    const req = httpMock.expectOne((request) =>
+      request.url === 'http://localhost:3000/signalk/v2/api/history/values'
+    );
+    expect(req.request.method).toBe('GET');
+    expect(req.request.params.get('paths')).toBe('navigation.speedThroughWater:average');
+    expect(req.request.params.get('duration')).toBe('PT10M');
+    expect(req.request.params.get('resolution')).toBe('1');
+
+    req.flush({
+      context: 'vessels.self',
+      range: { from: '2026-02-16T12:00:00.000Z', to: '2026-02-16T12:10:00.000Z' },
+      values: [{ path: 'navigation.speedThroughWater', method: 'average' }],
+      data: [['2026-02-16T12:00:00.000Z', 3.2]]
+    });
+
+    const response = await promise;
+    expect(response).toBeTruthy();
+    expect(response?.values[0].method).toBe('average');
+  });
+
   it('should fetch values from v2 history endpoint with resolution in seconds', async () => {
     connectionStub.serverServiceEndpoint$.next({
       operation: 2,
@@ -113,6 +148,56 @@ describe('SignalkHistoryService', () => {
     expect(response).toBeTruthy();
   });
 
+  it('should pass duration query to history paths endpoint', async () => {
+    connectionStub.serverServiceEndpoint$.next({
+      operation: 2,
+      message: 'Connected',
+      serverDescription: 'Signal K',
+      httpServiceUrl: 'http://localhost:3000/signalk/v1/api/',
+      WsServiceUrl: 'ws://localhost:3000/signalk/v1/stream'
+    });
+
+    const promise = service.getPaths({ duration: 'PT1H' });
+
+    const req = httpMock.expectOne((request) =>
+      request.url === 'http://localhost:3000/signalk/v2/api/history/paths'
+    );
+    expect(req.request.method).toBe('GET');
+    expect(req.request.params.get('duration')).toBe('PT1H');
+
+    req.flush(['navigation.speedThroughWater', 'environment.wind.speedTrue']);
+
+    const response = await promise;
+    expect(response).toEqual(['navigation.speedThroughWater', 'environment.wind.speedTrue']);
+  });
+
+  it('should pass from/to query to history contexts endpoint', async () => {
+    connectionStub.serverServiceEndpoint$.next({
+      operation: 2,
+      message: 'Connected',
+      serverDescription: 'Signal K',
+      httpServiceUrl: 'http://localhost:3000/signalk/v1/api/',
+      WsServiceUrl: 'ws://localhost:3000/signalk/v1/stream'
+    });
+
+    const promise = service.getContexts({
+      from: '2026-02-16T12:00:00.000Z',
+      to: '2026-02-16T12:01:00.000Z'
+    });
+
+    const req = httpMock.expectOne((request) =>
+      request.url === 'http://localhost:3000/signalk/v2/api/history/contexts'
+    );
+    expect(req.request.method).toBe('GET');
+    expect(req.request.params.get('from')).toBe('2026-02-16T12:00:00.000Z');
+    expect(req.request.params.get('to')).toBe('2026-02-16T12:01:00.000Z');
+
+    req.flush(['vessels.self', 'vessels.urn:mrn:signalk:uuid:example']);
+
+    const response = await promise;
+    expect(response).toEqual(['vessels.self', 'vessels.urn:mrn:signalk:uuid:example']);
+  });
+
   it('should pass numeric zero resolution when provided', async () => {
     connectionStub.serverServiceEndpoint$.next({
       operation: 2,
@@ -190,4 +275,25 @@ describe('SignalkHistoryService', () => {
     const response = await promise;
     expect(response).toBeNull();
   });
+
+  it('should return null when history contexts endpoint returns 500', async () => {
+    connectionStub.serverServiceEndpoint$.next({
+      operation: 2,
+      message: 'Connected',
+      serverDescription: 'Signal K',
+      httpServiceUrl: 'http://localhost:3000/signalk/v1/api/',
+      WsServiceUrl: 'ws://localhost:3000/signalk/v1/stream'
+    });
+
+    const promise = service.getContexts({ duration: 'PT10M' });
+
+    const req = httpMock.expectOne((request) =>
+      request.url === 'http://localhost:3000/signalk/v2/api/history/contexts'
+    );
+    expect(req.request.method).toBe('GET');
+    req.flush({ message: 'Server Error' }, { status: 500, statusText: 'Server Error' });
+
+    const response = await promise;
+    expect(response).toBeNull();
+  });
 });
diff --git a/src/app/core/services/signalk-history.service.ts b/src/app/core/services/signalk-history.service.ts
@@ -2,24 +2,15 @@ import { Injectable, inject, DestroyRef } from '@angular/core';
 import { HttpClient, HttpParams } from '@angular/common/http';
 import { firstValueFrom } from 'rxjs';
 import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import type { AggregateMethod, TimeRangeQueryParams } from '@signalk/server-api/history';
 import { SignalKConnectionService } from './signalk-connection.service';
 
-/**
- * Represents a single data point from the History API response.
- * The array format: [timestamp_string, value1, value2, ...]
- * where each value corresponds to the paths in the request.
- */
-export interface IHistoryDataPoint {
-  timestamp: string;
-  values: (number | string | null | number[])[];
-}
-
 /**
  * Represents a single series metadata from the History API response.
  */
-export interface IHistoryValueMetadata {
+interface IHistoryValueMetadata {
   path: string;
-  method?: string; // e.g., 'sma', 'avg', 'min', 'max'
+  method?: AggregateMethod | 'avg'; // keep 'avg' for compatibility with existing backends/tests
 }
 
 /**
@@ -36,16 +27,22 @@ export interface IHistoryValuesResponse {
 }
 
 /**
- * Query parameters for the History API.
+ * Query parameters supported by the /history/values endpoint in this app.
+ *
+ * Extends server-api query params while preserving current app compatibility:
+ * - allows string `resolution` passthrough (e.g. `PT1S`)
+ * - requires `paths` for the HTTP endpoint variant used by KIP
  */
-export interface IHistoryQueryParams {
-  from?: string;      // ISO 8601 date-time (inclusive)
-  to?: string;        // ISO 8601 date-time (inclusive, defaults to now)
-  duration?: string;  // ISO 8601 duration or milliseconds
-  paths: string;      // Required: comma-separated Signal K paths with optional aggregation
-  context?: string;   // Optional Signal K context, default 'vessels.self'
-  resolution?: string | number; // Optional: window length in seconds or time expression
-}
+type IHistoryValuesQueryParams = Partial<TimeRangeQueryParams> & {
+  paths: string;
+  context?: string;
+  resolution?: number | string;
+};
+
+/**
+ * Query parameters supported by history endpoints that only require a time range.
+ */
+type IHistoryTimeRangeQueryParams = Partial<TimeRangeQueryParams>;
 
 @Injectable({
   providedIn: 'root'
@@ -73,7 +70,7 @@ export class SignalkHistoryService {
   /**
    * Gets paths that have historical data available for the specified time range.
    *
-   * @param {Partial<IHistoryQueryParams>} params - Optional time range parameters.
+   * @param {IHistoryTimeRangeQueryParams} params - Optional time range parameters.
    *   - from: Start of the time range (ISO 8601), optional
    *   - to: End of the time range (ISO 8601), optional
    *   - duration: Duration of the time range (ISO 8601 or milliseconds), optional
@@ -91,7 +88,7 @@ export class SignalkHistoryService {
    *
    * @memberof SignalkHistoryService
    */
-  public async getPaths(params?: Partial<IHistoryQueryParams>): Promise<string[] | null> {
+  public async getPaths(params?: IHistoryTimeRangeQueryParams): Promise<string[] | null> {
     try {
       if (!this.historyServiceUrl) {
         console.warn('[SignalkHistoryService] No HTTP service URL available');
@@ -127,6 +124,60 @@ export class SignalkHistoryService {
     }
   }
 
+  /**
+   * Gets contexts that have historical data available for the specified time range.
+   *
+   * @param {IHistoryTimeRangeQueryParams} params - Optional time range parameters.
+   *   - from: Start of the time range (ISO 8601), optional
+   *   - to: End of the time range (ISO 8601), optional
+   *   - duration: Duration of the time range (ISO 8601 or milliseconds), optional
+   *
+   * @returns {Promise<string[] | null>} Array of Signal K contexts with historical data, or null if the request fails.
+   *
+   * @example
+   *   const contexts = await historyService.getContexts({ duration: 'PT1H' });
+   *   if (contexts) {
+   *     console.log('Available contexts:', contexts);
+   *   }
+   *
+   * @memberof SignalkHistoryService
+   */
+  public async getContexts(params?: IHistoryTimeRangeQueryParams): Promise<string[] | null> {
+    try {
+      if (!this.historyServiceUrl) {
+        console.warn('[SignalkHistoryService] No HTTP service URL available');
+        return null;
+      }
+
+      const historyUrl = `${this.historyServiceUrl}history/contexts`;
+      let httpParams = new HttpParams();
+
+      // Build query parameters (time range only)
+      if (params?.from) {
+        httpParams = httpParams.set('from', params.from);
+      }
+      if (params?.to) {
+        httpParams = httpParams.set('to', params.to);
+      }
+      if (params?.duration) {
+        httpParams = httpParams.set('duration', params.duration.toString());
+      }
+
+      const fullUrl = `${historyUrl}?${httpParams.toString()}`;
+      console.log(`[SignalkHistoryService] GET ${fullUrl}`);
+
+      const response = await firstValueFrom(
+        this.http.get<string[]>(historyUrl, { params: httpParams })
+      );
+
+      console.log(`[SignalkHistoryService] Retrieved ${response?.length ?? 0} available contexts`);
+      return response;
+    } catch (error) {
+      console.error('[SignalkHistoryService] History API /contexts request failed:', error);
+      return null;
+    }
+  }
+
   /**
    * Fetches historical data from the Signal K History API.
    *
@@ -135,7 +186,7 @@ export class SignalkHistoryService {
    * signalk-parquet. If no history is available or the API is not installed,
    * the request will fail.
    *
-   * @param {IHistoryQueryParams} params - Query parameters for the history request.
+   * @param {IHistoryValuesQueryParams} params - Query parameters for the history request.
    *   - paths (required): comma-separated Signal K paths with optional aggregation suffixes
    *     (e.g., 'navigation.speedOverGround:sma:5,navigation.speedThroughWater:avg')
    *   - from, to, duration: define the time range
@@ -159,7 +210,7 @@ export class SignalkHistoryService {
    *
    * @memberof SignalkHistoryService
    */
-  public async getValues(params: IHistoryQueryParams): Promise<IHistoryValuesResponse | null> {
+  public async getValues(params: IHistoryValuesQueryParams): Promise<IHistoryValuesResponse | null> {
     try {
       if (!this.historyServiceUrl) {
         console.warn('[SignalkHistoryService] No HTTP service URL available');
