Add getByRid to TrainsModule

package.json

@@ -30,8 +30,10 @@
   "author": "Frederick Boniface",
   "license": "GPL-3.0",
   "dependencies": {
-    "@owlboard/api-schema-types": "^3.0.3-alpha1",
-    "latlon-geohash": "^2.0.0"
+    "@owlboard/api-schema-types": "^3.0.3-alpha8",
+    "install": "^0.13.0",
+    "latlon-geohash": "^2.0.0",
+    "npm": "^11.13.0"
   },
   "devDependencies": {
     "@types/latlon-geohash": "^2.0.4",

src/index.ts

@@ -1,5 +1,5 @@
 export { OwlBoardClient } from './lib/client.js';
-export { ValidationError, ApiError } from './lib/errors.js';
+export { ValidationError, ApiError, type ApiErrorCode } from './lib/errors.js';
 
 // Re-export API Schema types
 export type * from '@owlboard/api-schema-types'

src/lib/base.ts

@@ -34,8 +34,9 @@ export class BaseClient {
 
     /**
      * Handles the Envelope logic
+     * @param fetcher - Optional custom fetch instance (e.g SvelteKit load fetch)
      */
-    public async request<T>(path: string, options: RequestInit = {}): Promise<ApiResult<T>> {
+    public async request<T>(path: string, options: RequestInit = {}, fetcher: typeof fetch = fetch): Promise<ApiResult<T>> {
         const url = `${this.baseUrl}${path}`;
         console.debug(`[API DEBUG] Calling: ${url}`);
         
@@ -43,7 +44,7 @@ export class BaseClient {
         headers.set('Content-Type', 'application/json');
         if (this.apiKey) headers.set('X-OWL-KEY', this.apiKey);
 
-        const response = await fetch(url, { ...options, headers });
+        const response = await fetcher(url, { ...options, headers });
 
         if (!response.ok && !response.headers.get('content-type')?.includes('application/json')) {
             throw new Error(`HTTP ${response.status}: ${response.statusText}`);

src/lib/validation.ts

@@ -25,6 +25,24 @@ export const IsValidCrs = (CRS: string): boolean => {
     return true;
 }
 
+/**
+ * Checks if a string is a valid RID, with 15-16 numeric characters
+ * @param rid The RID to validate
+ * @returns True/False - Whether valid or not
+ */
+export const IsValidRid = (rid: string): boolean => {
+    if (rid.length > 16 || rid.length < 15) {
+        return false
+    }
+    for (let i = 0; i < rid.length; i++) {
+        const char = rid.charCodeAt(i);
+        if (!isDigit(char)) {
+            return false
+        }
+    }
+    return true
+}
+
 /**
  * Checks if a string is a valid TIPLOC (Syntactically Only)
  * using byte level checking for max performance

src/modules/locationFilter.ts

@@ -4,12 +4,13 @@ import type { BaseClient, ApiResult } from '../lib/base.js';
 export class LocationFilterModule {
     constructor(private client: BaseClient) {}
 
-    async getLocationFilterData(): Promise<ApiResult<ApiLocationFilter.LocationFilterObject[]>> {
+    async getLocationFilterData(customFetch?: typeof fetch): Promise<ApiResult<ApiLocationFilter.LocationFilterObject[]>> {
         const path = '/locationFilter/data';
 
         return this.client.request<ApiLocationFilter.LocationFilterObject[]>(
             path,
-            {method: "GET"}
+            {method: "GET"},
+            customFetch,
         );
     }
 }

src/modules/pis.ts

@@ -6,7 +6,7 @@ import { ValidationError } from '../lib/errors.js';
 export class PisModule {
     constructor(private client: BaseClient) {}
 
-    async getByStartEndCrs(startCrs: string, endCrs: string): Promise<ApiResult<ApiPisObject.PisObjects[]>> {
+    async getByStartEndCrs(startCrs: string, endCrs: string, customFetch?: typeof fetch): Promise<ApiResult<ApiPisObject.PisObjects[]>> {
         if (!IsValidCrs(startCrs)) {
             throw new ValidationError("startCrs", "Invalid CRS Format")
         }
@@ -18,10 +18,10 @@ export class PisModule {
 
         return this.client.request<ApiPisObject.PisObjects[]>(path, {
             method: 'GET',
-        });
+        }, customFetch);
     }
 
-    async getByCode(code: string): Promise<ApiResult<ApiPisObject.PisObjects[]>> {
+    async getByCode(code: string, customFetch?: typeof fetch): Promise<ApiResult<ApiPisObject.PisObjects[]>> {
         if (!IsValidPis(code)) {
             throw new ValidationError("code", "Invalid PIS Code Format")
         }
@@ -30,6 +30,6 @@ export class PisModule {
 
         return this.client.request<ApiPisObject.PisObjects[]>(path, {
             method: 'GET',
-        })
+        }, customFetch)
     }
 }

src/modules/stationData.ts

@@ -22,7 +22,7 @@ export class StationDataModule {
      * @param geohash Geohash as string (up to six characters), generate using this.generateGeohash()
      * @returns Nearest Stations API Response (CRS, Name)
      */
-    async getNearestStations(geohash: string): Promise<ApiResult<ApiStationsNearestStations.StationsNearestStations[]>> {
+    async getNearestStations(geohash: string, customFetch?: typeof fetch): Promise<ApiResult<ApiStationsNearestStations.StationsNearestStations[]>> {
         if (!IsValidGeoHash(geohash)) {
             throw new ValidationError("hash", "Invalid Geohash requested");
         }
@@ -30,7 +30,7 @@ export class StationDataModule {
         const path = `/stationData/nearest/${geohash}`;
         return this.client.request<ApiStationsNearestStations.StationsNearestStations[]>(path, {
             method: 'GET',
-        })
+        }, customFetch)
     }
 
     // getStationSate(crs: string){}

src/modules/trains.ts

@@ -1,13 +1,13 @@
-import { ApiTrainsTrainByHeadcode } from '@owlboard/api-schema-types';
+import { ApiTrainsTrainByHeadcode, ApiTrainsTrainDetails } from '@owlboard/api-schema-types';
 import type { BaseClient, ApiResult } from '../lib/base.js';
-import { IsValidHeadcode, IsValidToc, IsValidDateStr } from '../lib/validation.js';
+import { IsValidHeadcode, IsValidRid, IsValidToc, IsValidDateStr } from '../lib/validation.js';
 import { ensureDateString } from '../lib/helpers.js';
 import { ValidationError } from '../lib/errors.js';
 
 export class TrainsModule {
     constructor(private client: BaseClient) { }
 
-    async getByHeadcode(headcode: string, date: string | Date = new Date, toc: string = ""): Promise<ApiResult<ApiTrainsTrainByHeadcode.TrainByHeadcodeResponse[]>> {
+    async getByHeadcode(headcode: string, date: string | Date = new Date, toc: string = "", customFetch?: typeof fetch): Promise<ApiResult<ApiTrainsTrainByHeadcode.TrainByHeadcodeResponse[]>> {
         if (!IsValidHeadcode(headcode)) {
             throw new ValidationError("headcode", "Invalid headcode format")
         }
@@ -29,6 +29,17 @@ export class TrainsModule {
 
         return this.client.request<ApiTrainsTrainByHeadcode.TrainByHeadcodeResponse[]>(path, {
             method: 'GET',
-        });
+        }, customFetch);
+    }
+
+    async getByRid(rid: string, customFetch?: typeof fetch): Promise<ApiResult<ApiTrainsTrainDetails.TrainDetailsResponse>> {
+        if (!IsValidRid(rid)) {
+            throw new ValidationError("RID", "Invalid RID format, must be 15-16 numerals")
+        }
+
+        const path = `/train/${rid}`
+        return this.client.request<ApiTrainsTrainDetails.TrainDetailsResponse>(path, {
+            method: 'GET',
+        }, customFetch);
     }
 }

tsconfig.json

@@ -7,9 +7,9 @@
 
     // Environment Settings
     // See also https://aka.ms/tsconfig/module
-    "module": "esnext",
+    "module": "nodenext",
     "target": "esnext",
-    "moduleResolution": "bundler",
+    "moduleResolution": "nodenext",
     "baseUrl": ".",
     "types": [],
     // For nodejs: