@ryancardin/noaa-tides-currents-mcp-server 2.0.0 → 2.1.0

package/dist/services/dpapi-service.js

@@ -1,164 +0,0 @@
-import axios from 'axios';
-// Base URL for the NOAA Derived Product API
-const DPAPI_BASE_URL = 'https://api.tidesandcurrents.noaa.gov/dpapi/prod';
-/**
- * Service for interacting with NOAA Derived Product API (DPAPI)
- */
-export class DpapiService {
-    /**
-     * Build parameters for the API request
-     * @param params Parameters for the request
-     * @returns URL-encoded parameters string
-     */
-    buildParams(params) {
-        // Remove undefined and null values
-        const filteredParams = Object.entries(params)
-            .filter(([_, value]) => value !== undefined && value !== null)
-            .reduce((acc, [key, value]) => {
-            acc[key] = value;
-            return acc;
-        }, {});
-        // Convert to URL parameters
-        return new URLSearchParams(filteredParams).toString();
-    }
-    /**
-     * Make a request to the DPAPI
-     * @param endpoint Endpoint path
-     * @param params Parameters for the request
-     * @returns Response data
-     */
-    async fetchDpapi(endpoint, params = {}) {
-        try {
-            const queryParams = this.buildParams(params);
-            const url = `${DPAPI_BASE_URL}${endpoint}${queryParams ? '?' + queryParams : ''}`;
-            const response = await axios.get(url);
-            return response.data;
-        }
-        catch (error) {
-            if (axios.isAxiosError(error) && error.response) {
-                throw new Error(`NOAA DPAPI Error: ${error.response.status} - ${JSON.stringify(error.response.data)}`);
-            }
-            throw error;
-        }
-    }
-    /**
-     * Get sea level trends for a station
-     * @param params Parameters including station ID and affiliation
-     * @returns Sea level trend data
-     */
-    async getSeaLevelTrends(params) {
-        const { station, affil = 'Global', format = 'json', ...rest } = params;
-        return this.fetchDpapi('/sltrends', {
-            station,
-            affil,
-            format,
-            ...rest
-        });
-    }
-    /**
-     * Get extreme water levels for a station
-     * @param params Parameters including station ID and units
-     * @returns Extreme water level data
-     */
-    async getExtremeWaterLevels(params) {
-        const { station, units = 'english', format = 'json', ...rest } = params;
-        return this.fetchDpapi('/ewl', {
-            station,
-            units,
-            format,
-            ...rest
-        });
-    }
-    /**
-     * Get high tide flooding daily count data
-     * @param params Parameters including station ID, date range, and thresholds
-     * @returns Daily flood count data
-     */
-    async getHighTideFloodingDaily(params) {
-        const { station, format = 'json', ...rest } = params;
-        return this.fetchDpapi('/htf/daily', {
-            station,
-            format,
-            ...rest
-        });
-    }
-    /**
-     * Get high tide flooding monthly count data
-     * @param params Parameters including station ID, date range, and thresholds
-     * @returns Monthly flood count data
-     */
-    async getHighTideFloodingMonthly(params) {
-        const { station, format = 'json', ...rest } = params;
-        return this.fetchDpapi('/htf/monthly', {
-            station,
-            format,
-            ...rest
-        });
-    }
-    /**
-     * Get high tide flooding seasonal count data
-     * @param params Parameters including station ID, seasons, and thresholds
-     * @returns Seasonal flood count data
-     */
-    async getHighTideFloodingSeasonal(params) {
-        const { station, format = 'json', ...rest } = params;
-        return this.fetchDpapi('/htf/seasonal', {
-            station,
-            format,
-            ...rest
-        });
-    }
-    /**
-     * Get high tide flooding annual count data
-     * @param params Parameters including station ID, year range, and thresholds
-     * @returns Annual flood count data
-     */
-    async getHighTideFloodingAnnual(params) {
-        const { station, format = 'json', ...rest } = params;
-        return this.fetchDpapi('/htf/annual', {
-            station,
-            format,
-            ...rest
-        });
-    }
-    /**
-     * Get high tide flooding decadal projections
-     * @param params Parameters including station ID, scenario, and decade
-     * @returns Decadal projection data
-     */
-    async getHighTideFloodingProjections(params) {
-        const { station, scenario = 'all', format = 'json', ...rest } = params;
-        return this.fetchDpapi('/htf/projections', {
-            station,
-            scenario,
-            format,
-            ...rest
-        });
-    }
-    /**
-     * Get high tide flooding daily likelihoods
-     * @param params Parameters including station ID and date
-     * @returns Daily likelihood data
-     */
-    async getHighTideFloodingLikelihoods(params) {
-        const { station, format = 'json', ...rest } = params;
-        return this.fetchDpapi('/htf/likelihoods', {
-            station,
-            format,
-            ...rest
-        });
-    }
-    /**
-     * Get top ten water levels for a station
-     * @param params Parameters including station ID and analysis type
-     * @returns Top ten water level data
-     */
-    async getTopTenWaterLevels(params) {
-        const { station, format = 'json', ...rest } = params;
-        return this.fetchDpapi('/topten', {
-            station,
-            format,
-            ...rest
-        });
-    }
-}

package/dist/services/noaa-parameters-service.d.ts

@@ -1,76 +0,0 @@
-/**
- * Provides information about valid NOAA Tides and Currents API parameters
- */
-export declare class NoaaParametersService {
-    /**
-     * Get valid time zone values
-     */
-    getTimeZones(): {
-        id: string;
-        description: string;
-    }[];
-    /**
-     * Get valid datum values
-     */
-    getDatums(): {
-        id: string;
-        description: string;
-    }[];
-    /**
-     * Get valid units
-     */
-    getUnits(): {
-        id: string;
-        description: string;
-    }[];
-    /**
-     * Get valid intervals for tide predictions
-     */
-    getTidePredictionIntervals(): {
-        id: string;
-        description: string;
-    }[];
-    /**
-     * Get valid intervals for current predictions
-     */
-    getCurrentPredictionIntervals(): {
-        id: string;
-        description: string;
-    }[];
-    /**
-     * Get valid velocity types for current predictions
-     */
-    getVelocityTypes(): {
-        id: string;
-        description: string;
-    }[];
-    /**
-     * Get valid meteorological products
-     */
-    getMeteorologicalProducts(): {
-        id: string;
-        description: string;
-    }[];
-    /**
-     * Get valid station types
-     */
-    getStationTypes(): {
-        id: string;
-        description: string;
-    }[];
-    /**
-     * Get valid date formats
-     */
-    getDateFormats(): {
-        format: string;
-        description: string;
-        example: string;
-    }[];
-    /**
-     * Get valid output formats
-     */
-    getOutputFormats(): {
-        id: string;
-        description: string;
-    }[];
-}

package/dist/services/noaa-parameters-service.js

@@ -1,128 +0,0 @@
-/**
- * Provides information about valid NOAA Tides and Currents API parameters
- */
-export class NoaaParametersService {
-    /**
-     * Get valid time zone values
-     */
-    getTimeZones() {
-        return [
-            { id: 'gmt', description: 'Greenwich Mean Time' },
-            { id: 'lst', description: 'Local Standard Time' },
-            { id: 'lst_ldt', description: 'Local Standard/Local Daylight Time' }
-        ];
-    }
-    /**
-     * Get valid datum values
-     */
-    getDatums() {
-        return [
-            { id: 'MHHW', description: 'Mean Higher High Water' },
-            { id: 'MHW', description: 'Mean High Water' },
-            { id: 'MTL', description: 'Mean Tide Level' },
-            { id: 'MSL', description: 'Mean Sea Level' },
-            { id: 'MLW', description: 'Mean Low Water' },
-            { id: 'MLLW', description: 'Mean Lower Low Water' },
-            { id: 'NAVD', description: 'North American Vertical Datum' },
-            { id: 'STND', description: 'Station Datum' }
-        ];
-    }
-    /**
-     * Get valid units
-     */
-    getUnits() {
-        return [
-            { id: 'english', description: 'English units (feet, mph, etc.)' },
-            { id: 'metric', description: 'Metric units (meters, kph, etc.)' }
-        ];
-    }
-    /**
-     * Get valid intervals for tide predictions
-     */
-    getTidePredictionIntervals() {
-        return [
-            { id: 'hilo', description: 'High/low tide predictions only' },
-            { id: 'h', description: 'Hourly predictions' },
-            { id: '6', description: '6-minute predictions' },
-            { id: '30', description: '30-minute predictions' },
-            { id: '60', description: '60-minute predictions' }
-        ];
-    }
-    /**
-     * Get valid intervals for current predictions
-     */
-    getCurrentPredictionIntervals() {
-        return [
-            { id: 'MAX_SLACK', description: 'Maximum flood/ebb and slack predictions only' },
-            { id: '6', description: '6-minute predictions' },
-            { id: '30', description: '30-minute predictions' },
-            { id: '60', description: '60-minute predictions' }
-        ];
-    }
-    /**
-     * Get valid velocity types for current predictions
-     */
-    getVelocityTypes() {
-        return [
-            { id: 'default', description: 'Default velocity reporting (flood/ebb direction)' },
-            { id: 'speed_dir', description: 'Speed and direction format' }
-        ];
-    }
-    /**
-     * Get valid meteorological products
-     */
-    getMeteorologicalProducts() {
-        return [
-            { id: 'air_temperature', description: 'Air temperature' },
-            { id: 'water_temperature', description: 'Water temperature' },
-            { id: 'wind', description: 'Wind speed and direction' },
-            { id: 'air_pressure', description: 'Barometric pressure' },
-            { id: 'air_gap', description: 'Air gap (distance between bridge and water surface)' },
-            { id: 'conductivity', description: 'Conductivity' },
-            { id: 'visibility', description: 'Visibility' },
-            { id: 'humidity', description: 'Relative humidity' },
-            { id: 'salinity', description: 'Salinity' },
-            { id: 'hourly_height', description: 'Verified hourly height water level' },
-            { id: 'high_low', description: 'Verified high/low water level' },
-            { id: 'daily_mean', description: 'Verified daily mean water level' },
-            { id: 'monthly_mean', description: 'Verified monthly mean water level' },
-            { id: 'one_minute_water_level', description: 'One-minute water level data' },
-            { id: 'datums', description: 'Datums' }
-        ];
-    }
-    /**
-     * Get valid station types
-     */
-    getStationTypes() {
-        return [
-            { id: 'waterlevels', description: 'Water level stations' },
-            { id: 'currentpredictions', description: 'Current prediction stations' },
-            { id: 'currents', description: 'Current observation stations' },
-            { id: 'tidepredictions', description: 'Tide prediction stations' },
-            { id: 'weather', description: 'Weather stations' },
-            { id: 'ports', description: 'Physical Oceanographic Real-Time System (PORTS) stations' }
-        ];
-    }
-    /**
-     * Get valid date formats
-     */
-    getDateFormats() {
-        return [
-            { format: 'YYYYMMDD', description: 'Year, month, day without separators', example: '20230401' },
-            { format: 'MM/DD/YYYY', description: 'Month/day/year with separators', example: '04/01/2023' },
-            { format: 'today', description: 'Current date', example: 'today' },
-            { format: 'latest', description: 'Latest available data', example: 'latest' },
-            { format: 'recent', description: 'Most recent data', example: 'recent' }
-        ];
-    }
-    /**
-     * Get valid output formats
-     */
-    getOutputFormats() {
-        return [
-            { id: 'json', description: 'JSON format' },
-            { id: 'xml', description: 'XML format' },
-            { id: 'csv', description: 'CSV format (not available for all endpoints)' }
-        ];
-    }
-}

package/dist/services/noaa-service.d.ts

@@ -1,52 +0,0 @@
-/**
- * Service for interacting with NOAA Tides and Currents APIs
- */
-export declare class NoaaService {
-    /**
-     * Build parameters for the API request
-     * @param params Parameters for the request
-     * @returns URL-encoded parameters string
-     */
-    private buildParams;
-    /**
-     * Make a request to the Data API
-     * @param params Parameters for the request
-     * @returns Response data
-     */
-    fetchDataApi(params: Record<string, any>): Promise<any>;
-    /**
-     * Make a request to the Metadata API
-     * @param endpoint Endpoint path
-     * @param params Parameters for the request
-     * @returns Response data
-     */
-    fetchMetadataApi(endpoint: string, params?: Record<string, any>): Promise<any>;
-    /**
-     * Get water level data
-     */
-    getWaterLevels(params: Record<string, any>): Promise<any>;
-    /**
-     * Get tide predictions
-     */
-    getTidePredictions(params: Record<string, any>): Promise<any>;
-    /**
-     * Get currents data
-     */
-    getCurrents(params: Record<string, any>): Promise<any>;
-    /**
-     * Get current predictions
-     */
-    getCurrentPredictions(params: Record<string, any>): Promise<any>;
-    /**
-     * Get meteorological data (air_temperature, wind, etc.)
-     */
-    getMeteorologicalData(params: Record<string, any>): Promise<any>;
-    /**
-     * Get list of stations
-     */
-    getStations(params: Record<string, any>): Promise<any>;
-    /**
-     * Get station details
-     */
-    getStationDetails(params: Record<string, any>): Promise<any>;
-}

package/dist/services/noaa-service.js

@@ -1,151 +0,0 @@
-import axios from 'axios';
-// Base URLs for the different NOAA APIs
-const DATA_API_BASE_URL = 'https://api.tidesandcurrents.noaa.gov/api/prod/datagetter';
-const METADATA_API_BASE_URL = 'https://api.tidesandcurrents.noaa.gov/mdapi/prod/webapi';
-/**
- * Service for interacting with NOAA Tides and Currents APIs
- */
-export class NoaaService {
-    /**
-     * Build parameters for the API request
-     * @param params Parameters for the request
-     * @returns URL-encoded parameters string
-     */
-    buildParams(params) {
-        // Remove undefined and null values
-        const filteredParams = Object.entries(params)
-            .filter(([_, value]) => value !== undefined && value !== null)
-            .reduce((acc, [key, value]) => {
-            acc[key] = value;
-            return acc;
-        }, {});
-        // Convert to URL parameters
-        return new URLSearchParams(filteredParams).toString();
-    }
-    /**
-     * Make a request to the Data API
-     * @param params Parameters for the request
-     * @returns Response data
-     */
-    async fetchDataApi(params) {
-        try {
-            const queryParams = this.buildParams(params);
-            const url = `${DATA_API_BASE_URL}?${queryParams}`;
-            const response = await axios.get(url);
-            return response.data;
-        }
-        catch (error) {
-            if (axios.isAxiosError(error) && error.response) {
-                throw new Error(`NOAA API Error: ${error.response.status} - ${JSON.stringify(error.response.data)}`);
-            }
-            throw error;
-        }
-    }
-    /**
-     * Make a request to the Metadata API
-     * @param endpoint Endpoint path
-     * @param params Parameters for the request
-     * @returns Response data
-     */
-    async fetchMetadataApi(endpoint, params = {}) {
-        try {
-            const queryParams = this.buildParams(params);
-            const url = `${METADATA_API_BASE_URL}${endpoint}${queryParams ? '?' + queryParams : ''}`;
-            const response = await axios.get(url);
-            return response.data;
-        }
-        catch (error) {
-            if (axios.isAxiosError(error) && error.response) {
-                throw new Error(`NOAA API Error: ${error.response.status} - ${JSON.stringify(error.response.data)}`);
-            }
-            throw error;
-        }
-    }
-    /**
-     * Get water level data
-     */
-    async getWaterLevels(params) {
-        return this.fetchDataApi({
-            ...params,
-            product: 'water_level'
-        });
-    }
-    /**
-     * Get tide predictions
-     */
-    async getTidePredictions(params) {
-        return this.fetchDataApi({
-            ...params,
-            product: 'predictions'
-        });
-    }
-    /**
-     * Get currents data
-     */
-    async getCurrents(params) {
-        return this.fetchDataApi({
-            ...params,
-            product: 'currents'
-        });
-    }
-    /**
-     * Get current predictions
-     */
-    async getCurrentPredictions(params) {
-        return this.fetchDataApi({
-            ...params,
-            product: 'currents_predictions'
-        });
-    }
-    /**
-     * Get meteorological data (air_temperature, wind, etc.)
-     */
-    async getMeteorologicalData(params) {
-        const { product, ...rest } = params;
-        return this.fetchDataApi({
-            ...rest,
-            product
-        });
-    }
-    /**
-     * Get list of stations
-     */
-    async getStations(params) {
-        const { type, name, lat_min, lat_max, lon_min, lon_max, state, limit, offset, sort_by, sort_order, ...rest } = params;
-        const endpoint = '/stations.' + (rest.format || 'json');
-        // Build query parameters with all the filters
-        const queryParams = { ...rest };
-        // Add filters only if they are defined
-        if (type)
-            queryParams.type = type;
-        if (name)
-            queryParams.name = name;
-        if (lat_min !== undefined)
-            queryParams.lat_min = lat_min;
-        if (lat_max !== undefined)
-            queryParams.lat_max = lat_max;
-        if (lon_min !== undefined)
-            queryParams.lon_min = lon_min;
-        if (lon_max !== undefined)
-            queryParams.lon_max = lon_max;
-        if (state)
-            queryParams.state = state;
-        if (limit !== undefined)
-            queryParams.limit = limit;
-        if (offset !== undefined)
-            queryParams.offset = offset;
-        if (sort_by)
-            queryParams.sort_by = sort_by;
-        if (sort_order)
-            queryParams.sort_order = sort_order;
-        return this.fetchMetadataApi(endpoint, queryParams);
-    }
-    /**
-     * Get station details
-     */
-    async getStationDetails(params) {
-        const { station, ...rest } = params;
-        const endpoint = `/stations/${station}/details.` + (rest.format || 'json');
-        return this.fetchMetadataApi(endpoint, rest);
-    }
-}