atmosx-nwws-parser 1.0.185 → 1.0.201

package/src/types.ts

@@ -0,0 +1,187 @@
+/*
+                                            _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ V / 
+       / /\ \| __| '_ ` _ \ / _ \/ __| '_ \| '_ \ / _ \ '__| |/ __| > <  
+      / ____ \ |_| | | | | | (_) \__ \ |_) | | | |  __/ |  | | (__ / . \ 
+     /_/    \_\__|_| |_| |_|\___/|___/ .__/|_| |_|\___|_|  |_|\___/_/ \_\
+                                     | |                                 
+                                     |_|                                                                                                                
+    
+    Written by: k3yomi@GitHub                        
+*/
+
+interface GlobalSettings { 
+    useParentEvents: boolean,
+    betterEventParsing: boolean 
+    easSettings: { 
+        easAlerts: string[], 
+        easDirectory: string, 
+        easIntroWav: string | null 
+    },  
+    alertFiltering: { 
+        filteredEvents: string[], 
+        filteredICOAs: string[], 
+        ignoredICOAs: string[], 
+        ugcFilter: string[], 
+        stateFilter: string[], 
+        ignoredEvents: string[], 
+        checkExpired: boolean 
+    }, 
+}
+
+interface DefaultParameters { 
+    wmo: string,
+    source: string,
+    max_hail_size: string,
+    max_wind_gust: string,
+    damage_threat: string,
+    tornado_detection: string,
+    flood_detection: string,
+    discussion_tornado_intensity: string,
+    discussion_wind_intensity: string,
+    discussion_hail_intensity: string
+    WMOidentifier?: string[],
+    VTEC?: string,
+    maxHailSize?: string,
+    maxWindGust?: string,
+    thunderstormDamageThreat?: string[],
+    tornadoDetection?: string[],
+    waterspoutDetection?: string[],
+    floodDetection?: string[],
+    AWIPSidentifier?: string[],
+    NWSheadline?: string[],
+}
+
+interface DefaultAttributes { 
+    xmlns?: string, 
+    id?: string, 
+    issue?: string, 
+    ttaaii?: string, 
+    cccc?: string, 
+    awipsid?: string, 
+    getAwip?: Record<string, string>
+}
+
+interface ClientReconnectSettings { 
+    canReconnect: boolean, 
+    currentInterval: number 
+}
+
+interface ClientCredentialSettings { 
+    username: string, 
+    password: string, 
+    nickname: string 
+}
+
+interface ClientCacheSettings { 
+    read: boolean,
+    maxSizeMB: number, 
+    directory: string, 
+    maxHistory: number 
+}
+
+interface ClientAlertSettings { 
+    isCapOnly: boolean, 
+    isShapefileUGC: boolean 
+}
+
+interface NoaaWeatherWireServiceSettings { 
+    clientReconnections: ClientReconnectSettings, 
+    clientCredentials: ClientCredentialSettings,
+    cache: ClientCacheSettings, 
+    alertPreferences: ClientAlertSettings 
+}
+
+interface NationalWeatherServiceSettings { 
+    checkInterval: number, 
+    endpoint: string 
+}
+
+export interface EnhancedEventCondition { 
+    description?: string; 
+    condition?: (value: string) => boolean; 
+}
+
+export interface TypeAttributes { 
+    awipsType?: Record<string, string>, 
+    isCap: boolean, 
+    awipsid?: string, 
+    raw: boolean, 
+    issue?: string, 
+    type?: string, 
+    prefix?: string, 
+    getAwip?: { type: string, prefix: string }
+}
+
+export interface NationalWeatherServiceResponse { 
+    error: boolean,
+    message?: { features: TypeAlert[] }
+}
+
+export interface VTECParsed { 
+    raw: string, 
+    tracking: string, 
+    event: string, 
+    status: string, 
+    wmo: string, 
+    expires: string 
+}
+export interface UGCParsed { 
+    zones: string[], 
+    locations: string[], 
+    expiry: Date | null, 
+    polygon: [number, number][] 
+}
+
+export interface BaseProperties {
+    event?: string, 
+    locations: string,
+    issued: string,
+    expires: string,
+    geocode: { UGC: string[] },
+    description: string,
+    sender_name: string,
+    sender_icao: string,
+    attributes: DefaultAttributes,
+    parameters: DefaultParameters,
+    geometry: { type?: string, coordinates?: [number, number][] } | null
+    messageType?: string,
+    sent?: string,
+    areaDesc?: string,
+}
+
+export interface TypeAlert { 
+    performance: number, 
+    tracking: string,
+    header: string,
+    vtec: string,
+    history: { description: string, issued: string, type: string }[],
+    properties: BaseProperties
+    geometry: { type?: string, coordinates?: [number, number][] } | null
+}
+
+export interface ClientSettings {
+    database?: string,
+    isNWWS: boolean,
+    NoaaWeatherWireService: NoaaWeatherWireServiceSettings,
+    NationalWeatherService: NationalWeatherServiceSettings,
+    global: GlobalSettings,
+}
+
+export interface TypeCompiled { 
+    message: string | null,
+    attributes: DefaultAttributes,
+    isCap: boolean,
+    isApi: boolean,
+    isCapDescription: boolean,
+    isVtec: boolean,
+    isUGC: boolean,
+    getAwip?: { type: string, prefix: string },
+    awipsType: { type: string, prefix: string } | null,
+    awipsPrefix?: string,
+    ignore: boolean,
+}
+
+
+export type HTTPSettings = { timeout?: number, headers?: Record<string, string> }

package/src/utils.ts

@@ -0,0 +1,217 @@
+/*
+                                            _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ V / 
+       / /\ \| __| "_ ` _ \ / _ \/ __| "_ \| "_ \ / _ \ "__| |/ __| > <  
+      / ____ \ |_| | | | | | (_) \__ \ |_) | | | |  __/ |  | | (__ / . \ 
+     /_/    \_\__|_| |_| |_|\___/|___/ .__/|_| |_|\___|_|  |_|\___/_/ \_\
+                                     | |                                 
+                                     |_|                                                                                                                
+    
+    Written by: KiyoWx (k3yomi)                
+*/
+
+
+import * as loader from './bootstrap';
+import * as types from './types';
+import StanzaParser from './parsers/stanza';
+import EventParser from './parsers/events';
+import Xmpp from './xmpp';
+
+export class Utils { 
+
+    /**
+     * Zzzzzzz... yeah not much to explain here. Simple sleep function that returns a promise after the specified milliseconds.
+     *
+     * @public
+     * @static
+     * @async
+     * @param {number} ms 
+     * @returns {Promise<void>} 
+     */
+    public static async sleep(ms: number): Promise<void> {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    
+    /**
+     * loadCollectionCache reads cached alert files from the specified cache directory and processes them.
+     *
+     * @public
+     * @static
+     * @async
+     * @returns {Promise<void>} 
+     */
+    public static async loadCollectionCache(): Promise<void> {
+        try {
+            const settings = loader.settings as types.ClientSettings;
+            if (settings.NoaaWeatherWireService.cache.read && settings.NoaaWeatherWireService.cache.directory) {
+                if (!loader.packages.fs.existsSync(settings.NoaaWeatherWireService.cache.directory)) return;
+                const cacheDir = settings.NoaaWeatherWireService.cache.directory;
+                const getAllFiles = loader.packages.fs.readdirSync(cacheDir).filter((file: string) => file.endsWith('.bin') && file.startsWith('cache-'));
+                for (const file of getAllFiles) {
+                    const filepath = loader.packages.path.join(cacheDir, file);
+                    const readFile = loader.packages.fs.readFileSync(filepath, { encoding: 'utf-8' });
+                    const readSize = loader.packages.fs.statSync(filepath).size;
+                    if (readSize == 0) { continue; }
+                    const isCap = readFile.includes(`<?xml`);
+                    if (isCap && !settings.NoaaWeatherWireService.alertPreferences.isCapOnly) continue;
+                    if (!isCap && settings.NoaaWeatherWireService.alertPreferences.isCapOnly) continue;
+                    const validate = StanzaParser.validate(readFile, { awipsid: file, isCap: isCap, raw: true, issue: undefined });
+                    await EventParser.eventHandler(validate);
+                }
+            }
+        } catch (error: any) {
+            loader.cache.events.emit('onError', { code: 'error-load-cache', message: `Failed to load cache: ${error.message}`});
+        }
+    }
+
+    /**
+     * loadGeoJsonData fetches GeoJSON data from the National Weather Service endpoint and processes each alert.
+     *
+     * @public
+     * @static
+     * @async
+     * @returns {Promise<void>} 
+     */
+    public static async loadGeoJsonData(): Promise<void> {
+        try {
+            const settings = loader.settings as types.ClientSettings;
+            const response = await this.createHttpRequest(settings.NationalWeatherService.endpoint) as types.NationalWeatherServiceResponse
+            if (!response.error) { 
+                EventParser.eventHandler({message: JSON.stringify(response.message), attributes: {}, isCap: true, isApi: true, isVtec: false, isUGC: false, isCapDescription: false, awipsType: { type: 'api', prefix: 'AP' }, ignore: false});
+            }
+        } catch (error: any) {
+            loader.cache.events.emit('onError', { code: 'error-fetching-nws-data', message: `Failed to fetch NWS data: ${error.message}`});
+        }
+    }
+
+    /**
+     * detectUncaughtExceptions sets up a global handler for uncaught exceptions in the Node.js process,
+     *
+     * @public
+     * @static
+     */
+    public static detectUncaughtExceptions(): void {
+        if (process.listeners('uncaughtException').some(l => l.name === 'uncaughtExceptionHandler')) return;
+        process.on(`uncaughtException`, (error: Error) => {
+            loader.cache.events.emit(`onError`, {message: `Uncaught Exception: ${error.message}`, code: `error-uncaught-exception`, stack: error.stack});
+        })
+    }
+    
+    /**
+     * createHttpRequest performs an HTTP GET request to the specified URL with optional settings.
+     *
+     * @public
+     * @static
+     * @async
+     * @param {string} url 
+     * @param {?types.HTTPSettings} [options] 
+     * @returns {unknown} 
+     */
+    public static async createHttpRequest(url: string, options?: types.HTTPSettings) {
+        const defaultOptions = { 
+            timeout: 10000,
+            headers: { 
+                "User-Agent": "AtmosphericX",
+                "Accept": "application/geo+json, text/plain, */*; q=0.9",
+                "Accept-Language": "en-US,en;q=0.9"
+            }
+        };
+        const requestOptions = {
+            ...defaultOptions,
+            ...options,
+            headers: { ...defaultOptions.headers, ...(options?.headers ?? {}) }
+        };
+        try {
+            const resp = await loader.packages.axios.get(url, {
+                headers: requestOptions.headers,
+                timeout: requestOptions.timeout,
+                maxRedirects: 0,
+                validateStatus: (status) => status === 200 || status === 500
+            });
+            return { error: false, message: resp.data };
+        } catch (err: any) {
+            return { error: true, message: err?.message ?? String(err) };
+        }
+    }
+
+    /**
+     * garbageCollectionCache removes files from the cache directory that exceed the specified maximum file size in megabytes.
+     *
+     * @public
+     * @static
+     * @param {number} maxFileMegabytes 
+     */
+    public static garbageCollectionCache(maxFileMegabytes: number): void {
+        try {
+            const settings = loader.settings as types.ClientSettings;
+            if (!settings.NoaaWeatherWireService.cache.directory) return;
+            if (!loader.packages.fs.existsSync(settings.NoaaWeatherWireService.cache.directory)) return;
+            const maxBytes = maxFileMegabytes * 1024 * 1024;
+            const cacheDirectory = settings.NoaaWeatherWireService.cache.directory;
+            const stackFiles: string[] = [cacheDirectory], files: { 
+                file: string,
+                size: number,
+            }[] = [];
+            while (stackFiles.length) { 
+                const currentDirectory = stackFiles.pop();
+                loader.packages.fs.readdirSync(currentDirectory).forEach((file: string) => {
+                    const fullPath = loader.packages.path.join(currentDirectory, file);
+                    const stat = loader.packages.fs.statSync(fullPath)
+                    if (stat.isDirectory()) stackFiles.push(fullPath) ;
+                    else files.push({ file: fullPath, size: stat.size });
+                })
+            }
+            if (!files.length) return;
+            files.forEach(f => {
+                if (f.size > maxBytes) loader.packages.fs.unlinkSync(f.file);
+            })
+        } catch (error: any) {
+            loader.cache.events.emit('onError', { code: 'error-garbage-collection', message: `Failed to perform garbage collection: ${error.message}`});
+        }
+    }
+
+    /**
+     * handleCronJob performs periodic tasks based on whether the client is connected to NWWS or fetching data from NWS.
+     *
+     * @public
+     * @static
+     * @param {boolean} isNwws 
+     */
+    public static handleCronJob(isNwws: boolean): void {
+        try { 
+            const settings = loader.settings as types.ClientSettings;
+            if (isNwws) { 
+                if (settings.NoaaWeatherWireService.cache.read ) void this.garbageCollectionCache(settings.NoaaWeatherWireService.cache.maxSizeMB);
+                if (settings.NoaaWeatherWireService.clientReconnections.canReconnect ) void Xmpp.isSessionReconnectionEligible(settings.NoaaWeatherWireService.clientReconnections.currentInterval);
+            } else {
+                void this.loadGeoJsonData();
+            }
+        } catch (error: any) {
+            loader.cache.events.emit('onError', { code: 'error-cron-job', message: `Failed to perform scheduled tasks: ${error.message}`});
+        }
+    }
+
+    /**
+     * mergeClientSettings merges user-provided settings into the existing client settings, allowing for nested objects to be merged correctly.
+     *
+     * @public
+     * @static
+     * @param {Record<string, any>} target 
+     * @param {Record<string, any>} settings 
+     */
+    public static mergeClientSettings(target: Record<string, any>, settings: Record<string, any>): void {
+        for (const key in settings) {
+            if (settings.hasOwnProperty(key)) {
+                if (typeof settings[key] === 'object' && settings[key] !== null && !Array.isArray(settings[key])) {
+                    if (!target[key] || typeof target[key] !== 'object') { target[key] = {};  }
+                    this.mergeClientSettings(target[key], settings[key]);
+                } else {
+                    target[key] = settings[key];
+                }
+            }
+        }
+    }
+}
+
+export default Utils;

package/src/xmpp.ts

@@ -0,0 +1,123 @@
+/*
+                                            _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ V / 
+       / /\ \| __| "_ ` _ \ / _ \/ __| "_ \| "_ \ / _ \ "__| |/ __| > <  
+      / ____ \ |_| | | | | | (_) \__ \ |_) | | | |  __/ |  | | (__ / . \ 
+     /_/    \_\__|_| |_| |_|\___/|___/ .__/|_| |_|\___|_|  |_|\___/_/ \_\
+                                     | |                                 
+                                     |_|                                                                                                                
+    
+    Written by: KiyoWx (k3yomi)                
+*/
+
+
+import * as loader from './bootstrap';
+import * as types from './types';
+import Utils from './utils';
+import StanzaParser from './parsers/stanza';
+import Database from './database';
+import EventParser from './parsers/events';
+
+
+export class Xmpp { 
+    
+    /**
+     * isSessionReconnectionEligible checks if the XMPP session is eligible for reconnection based on the last 
+     * received stanza time and current interval.
+     *
+     * @public
+     * @static
+     * @async
+     * @param {number} currentInterval 
+     * @returns {Promise<void>} 
+     */
+    public static async isSessionReconnectionEligible(currentInterval: number): Promise<void> {
+        const settings = loader.settings as types.ClientSettings;
+        if ((loader.cache.isConnected || loader.cache.sigHalt ) && loader.cache.session) { 
+            const lastStanza = Date.now() - loader.cache.lastStanza;
+            if (lastStanza >= (currentInterval * 1000)) {
+                if (!loader.cache.attemptingReconnect) { 
+                    loader.cache.attemptingReconnect = true;
+                    loader.cache.isConnected = false;
+                    loader.cache.totalReconnects += 1;
+                    loader.cache.events.emit(`onReconnect`, { reconnects: loader.cache.totalReconnects, lastStanza: lastStanza, lastName: settings.NoaaWeatherWireService.clientCredentials.nickname})
+                    await loader.cache.session.stop().catch(() => {});
+                    await loader.cache.session.start().catch(() => {});
+                }
+            }
+        }
+    }  
+
+    /**
+     * deploySession initializes and starts the XMPP client session, setting up event listeners for 
+     * connection management and message handling. This function is specifically tailored for
+     * NoaaWeatherWireService and connects to their XMPP server.
+     *
+     * @public
+     * @static
+     * @async
+     * @returns {Promise<void>} 
+     */
+    public static async deploySession(): Promise<void> { 
+        const settings = loader.settings as types.ClientSettings
+        loader.cache.session = loader.packages.xmpp.client({
+            service: `xmpp://nwws-oi.weather.gov`, 
+            domain: `nwws-oi.weather.gov`,
+            username: settings.NoaaWeatherWireService.clientCredentials.username,
+            password: settings.NoaaWeatherWireService.clientCredentials.password,
+        });
+        settings.NoaaWeatherWireService.clientCredentials.nickname ??= settings.NoaaWeatherWireService.clientCredentials.username;
+        loader.cache.session.on(`online`, async (address: string) => {
+            if (loader.cache.lastConnect && Date.now() - loader.cache.lastConnect < 10 * 1000) {
+                loader.cache.sigHalt = true;
+                Utils.sleep(2 * 1000).then(async () => { 
+                    await loader.cache.session.stop()
+                 });
+                loader.cache.events.emit(`onError`, { code: `error-reconnecting-too-fast`, message: `The client is attempting to reconnect too fast. Please wait a few seconds before trying again.` });
+                return;
+            }
+            loader.cache.isConnected = true;
+            loader.cache.sigHalt = false;
+            loader.cache.lastConnect = Date.now();
+            loader.cache.session.send(loader.packages.xmpp.xml('presence', { to: `nwws@conference.nwws-oi.weather.gov/${settings.NoaaWeatherWireService.clientCredentials.nickname}`, xmlns: 'http://jabber.org/protocol/muc' }))
+            loader.cache.session.send(loader.packages.xmpp.xml('presence', { to: `nwws@conference.nwws-oi.weather.gov`, type: 'available' }))
+            loader.cache.events.emit(`onConnection`, settings.NoaaWeatherWireService.clientCredentials.nickname)
+            if (loader.cache.attemptingReconnect) { 
+                Utils.sleep(15 * 1000).then(() => { loader.cache.attemptingReconnect = false; })
+            }
+        });
+        loader.cache.session.on(`offline`, async () => {
+            loader.cache.isConnected = false;
+            loader.cache.sigHalt = true;
+            loader.cache.events.emit(`onError`, { code: `connection-lost`, message: `XMPP connection went offline` });
+        });
+        loader.cache.session.on(`error`, async (error: Error) => {
+            loader.cache.isConnected = false;
+            loader.cache.sigHalt = true;
+            loader.cache.events.emit(`onError`, { code: `connection-error`, message: error.message });
+        });
+        loader.cache.session.on(`stanza`, async (stanza: any) => {
+            try {
+                loader.cache.lastStanza = Date.now()
+                if (stanza.is(`message`)) {
+                    const validate = StanzaParser.validate(stanza);
+                    if ( validate.ignore || (validate.isCap && !settings.NoaaWeatherWireService.alertPreferences.isCapOnly) || (!validate.isCap && settings.NoaaWeatherWireService.alertPreferences.isCapOnly) || (validate.isCap && !validate.isCapDescription) ) return;
+                    EventParser.eventHandler(validate);
+                    loader.cache.events.emit(`onMessage`, validate)
+                    Database.stanzaCacheImport(JSON.stringify(validate))
+                }
+                if (stanza.is(`presence`) && stanza.attrs.from && stanza.attrs.from.startsWith('nwws@conference.nwws-oi.weather.gov/')) {
+                    const occupant = stanza.attrs.from.split('/').slice(1).join('/');
+                    loader.cache.events.emit('onOccupant', { occupant, type: stanza.attrs.type === 'unavailable' ? 'unavailable' : 'available' });
+                }
+            } catch (e) {
+                loader.cache.events.emit(`onError`, {code: `error-processing-stanza`, message: (e as Error).message})
+            }
+        });
+        await loader.cache.session.start()
+    }
+
+}
+
+export default Xmpp;

package/test.js

@@ -1,36 +1 @@
-AtmosXWireParser = require(`./index.js`);
-
-let Client = new AtmosXWireParser({
-    alertSettings: { 
-        onlyCap: false, // Set to true to only receive CAP messages only
-        betterEvents: true, // Set to true to receive better event handling
-        ugcPolygons: false, // Set to true to receive UGC Polygons instead of reading from raw products. 
-        expiryCheck: true, // Set to true to filter out expired alerts
-        filteredAlerts: [] // Alerts you want to only log, leave empty to receive all alerts (Ex. ["Tornado Warning", "Radar Indicated Tornado Warning"])
-    },
-    xmpp: {
-        reconnect: true, // Set to true to enable automatic reconnection if you lose connection
-        reconnectInterval: 60, // Interval in seconds to attempt reconnection
-    },
-    cacheSettings: {
-        maxMegabytes: 2, // Maximum cache size in megabytes
-        cacheDir: `./cache`, // Directory for cache files
-        readCache: false, // Set to true if you wish to reupload the cache from earlier
-    },
-    authentication: {
-        username: `USERNAME_HERE`, // Your XMPP username
-        password: `PASSWORD_HERE`, // Your XMPP password
-        display: `DISPLAY_NAME` // Display name for your XMPP client
-    },
-    database: `./database.db`, // Path to the SQLite database file (It will be created if it doesn't exist and will be used to store UGC counties and zones.)
-});
-
-Client.onEvent(`onAlert`, (alert) => {console.log(alert)});
-Client.onEvent(`onStormReport`, (report) => {});
-Client.onEvent(`onMesoscaleDiscussion`, (discussions) => {});
-Client.onEvent(`onMessage`, (message) => {});
-Client.onEvent(`onOccupant`, (occupant) => {});
-Client.onEvent(`onError`, (error) => {console.log(error)});
-Client.onEvent(`onReconnect`, (service) => { 
-    Client.setDisplayName(`${username} (x${service.reconnects})`)
-})
+// TODO:

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+	"compilerOptions": {
+		"target": "ES6",
+		"module": "ESNext",
+		"moduleResolution": "Node",
+		"outDir": "dist",
+		"declaration": true,
+		"declarationDir": "dist/types",
+		"esModuleInterop": true,
+		"allowSyntheticDefaultImports": true,
+		"skipLibCheck": true
+	},
+	"include": ["src"]
+}

package/tsup.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+	entry: ['src/**/*.ts'],
+	format: ['esm', 'cjs'],
+	outDir: 'dist',
+	splitting: false,
+	clean: true,
+	outExtension({ format }) {return {js: format === 'esm' ? '.mjs' : '.cjs',};},
+	esbuildOptions(options, context) { options.outdir = `dist/${context.format}`; },
+});