@atmosx/event-product-parser 3.0.3 → 3.0.6

package/src/@events/{events.vtec.ts → ParseVTEC.ts}

@@ -17,21 +17,20 @@
 
 */
 
-import { TypeAttributes } from "../@types/types.attributes";
-import { TypeStanzaCompiled } from "../@types/types.compiled"
-import { TypeEvent } from "../@types/type.event";
-import { TypePVTEC } from "../@types/types.pvtec";
-import { TypeHVTEC } from "../@types/types.hvtec";
-import { pvExtract } from "../@parsers/@pvtec/pvtec.extract";
-import { hvExtract } from "../@parsers/@hvtec/hvtec.extract";
-import { ugcExtract } from "../@parsers/@ugc/ugc.extract";
-import { properties } from "../@building/building.properties";
-import { getEventHeader } from "../@building/building.headers";
-import { getEventTracking } from "../@building/building.tracking";
-import { validateEvents } from "../@building/building.validate";
+import { TypeAttributes } from "../@types/Attributes";
+import { TypeStanzaCompiled } from "../@types/StanzaCompiled"
+import { TypePVTEC } from "../@types/VTEC";
+import { TypeHVTEC } from "../@types/HVTEC";
+import { bootstrap } from "../bootstrap";
+import { VTECExtract } from "../@parsers/@pvtec/VTECExtract";
+import { HVExtract } from "../@parsers/@hvtec/HVExtract";
+import { ugcExtract } from "../@parsers/@ugc/UGCExtract";
+import { GetEventProperties } from "../@building/GetEventProperties";
+import { GetEventHeader } from "../@building/GetEventHeader";
+import { GetEventTracking } from "../@building/GetEventTracking";
+import { SetDebug } from "../@modules/@utilities/SetDebug";
 
-export const vtec = async (stanza: TypeStanzaCompiled): Promise<void> => {
-    let processed: TypeEvent[] = [];
+export const ParseVTEC = async (stanza: TypeStanzaCompiled): Promise<void> => {
     const getMessages = stanza?.message
         ?.split(/(?=\$\$)/g)
         ?.map(message => message.trim())
@@ -40,17 +39,17 @@ export const vtec = async (stanza: TypeStanzaCompiled): Promise<void> => {
     for (const message of getMessages) {
         const tick = performance.now();
         const attributes = stanza?.attributes as TypeAttributes
-        const pVtec = pvExtract(message) as TypePVTEC[];
-        const hVtec = hvExtract(message) as TypeHVTEC[];
+        const pVtec = VTECExtract(message) as TypePVTEC[];
+        const hVtec = HVExtract(message) as TypeHVTEC[];
         const ugc = await ugcExtract(message)
         if (pVtec != null && ugc != null ) {
             for (const pv of pVtec) {
                 const vtec = pv;
-                const props = properties({ message, attributes, ugc, pVtec: vtec })
-                const header = getEventHeader({properties: props, getType: stanza.getType, vtec: vtec})
+                const props = GetEventProperties({ message, attributes, ugc, pVtec: vtec })
+                const header = GetEventHeader({properties: props, getType: stanza.getType, vtec: vtec})
                 const issued = new Date(attributes.issue)?? new Date()
                 const expires = new Date(vtec.expires)
-                processed.push({
+                bootstrap.cache.processed.push({
                     type: `Feature`,
                     geometry: {
                         type: `Point`,
@@ -66,10 +65,11 @@ export const vtec = async (stanza: TypeStanzaCompiled): Promise<void> => {
                         metadata: {
                             ms: performance.now() - tick,
                             source: `events.vtec`,
-                            tracking: getEventTracking({ type: `VTEC`, stanza, attributes, properties: props, vtec }),
+                            tracking: GetEventTracking({ type: `VTEC`, stanza, attributes, properties: props, vtec }),
                             header: header,
                             vtec: pv,
                             hvtec: hVtec,
+                            raw: message,
                             history: [
                                 {
                                     description: props.description,
@@ -80,8 +80,8 @@ export const vtec = async (stanza: TypeStanzaCompiled): Promise<void> => {
                         }
                     }
                 })
+                SetDebug({ title: `ParseVTEC`, message: `${Math.round(performance.now() - tick)}ms` })
             }
         }
     }
-    validateEvents(processed)
 }

package/src/@manager/CreateActions.ts

@@ -0,0 +1,213 @@
+/*
+              _                             _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ V / 
+       / /\ \| __| '_ ` _ \ / _ \/ __| '_ \| '_ \ / _ \ '__| |/ __| > <  
+      / ____ \ |_| | | | | | (_) \__ \ |_) | | | |  __/ |  | | (__ / . \ 
+     /_/    \_\__|_| |_| |_|\___/|___/ .__/|_| |_|\___|_|  |_|\___/_/ \_\
+                                     | |                            
+                                     |_|                                                                                                                
+
+    Created with ♥ by the AtmosphericX Team (KiyoWx, StarflightWx, & CJ Ziegler)
+    Discord: https://atmosphericx-discord.scriptkitty.cafe
+    Ko-Fi: https://ko-fi.com/k3yomi
+    Documentation: http://localhost/documentation | https://atmosphericx.scriptkitty.cafe/documentation
+
+    Internal Package: @atmosx/event-product-parser
+
+*/
+
+import { TypeSettings } from "../@types/Settings";
+import { TypeEvent } from "../@types/Event";
+import { TypeActions } from "../@types/Actions";
+import { bootstrap } from "../bootstrap"
+import { GenerateEASMessage } from "../@modules/@eas/GenerateEASMessage"
+import { SetTimeoutAction } from "../@modules/@utilities/SetTimeoutAction";
+import { GetEmebedText } from "../@parsers/@text/GetEmbededText";
+import { GetStringText } from "../@parsers/@text/GetStringText";
+import { GetCleanedEvent } from "../@building/GetCleanedEvent"
+import { CreateHttp } from "../@modules/@utilities/CreateHttp";
+import { SetDebug } from "../@modules/@utilities/SetDebug";
+import { GetMatched } from "../@modules/@utilities/GetMatched";
+import { existsSync, mkdirSync, writeFileSync, readFileSync, appendFileSync } from "fs";
+
+
+export const CreateActions = async (event: TypeEvent): Promise<void> => {
+    const tick = performance.now()
+    const settings = bootstrap.settings as TypeSettings;
+    const notifyServer = settings.NotifyServer;
+    const actions = settings.ActionSettings as TypeActions[];
+    const properties = event.properties;
+    const hasActions = Array.isArray(actions) && actions.length > 0;
+    if (!hasActions) {
+        SetDebug({ title: `CreateActions`, message: `${Math.round(performance.now() - tick)}ms` });
+        return;
+    }
+    const metadata = { 
+        text: null,
+        eas: null,
+        json: null,
+        name: properties.event,
+        status: properties.status,
+        description: properties.description,
+        tracking: properties.metadata.tracking,
+        header: properties.metadata.header,
+        raw: properties.metadata.raw,
+        expired: properties.status_metadata.is_expired,
+        attachments: properties.metadata.attachments
+    }
+
+    for (const action of actions) {
+        const events = action?.Events;
+        const webhook = action?.Webhook;
+        const notify = action?.NotificationServer;
+        const uploads = action?.Uploads
+        const isMatched = GetMatched(events ?? [], metadata.name)
+
+        if (events?.length == 0 || isMatched) {
+            if (uploads?.EAS) { 
+                metadata.eas = await GenerateEASMessage({
+                    title: `${metadata.name}_${metadata.status}_${metadata.tracking}`,
+                    message: metadata.description,
+                    header: metadata.header
+                });
+            }
+
+            if (uploads?.TEXT) {
+                const fDestination = settings.GlobalSettings.ArchiveSettings.TextDirectory;
+                if (fDestination) {
+                    const file = (`${fDestination}/${metadata.name}_${metadata.tracking}.txt`).replace(/[\\:*?"<>|]/g, "_").replace(/\s+/g, " ").trim();
+                    if (!existsSync(fDestination)) { mkdirSync(fDestination, { recursive: true }); }
+                    if (existsSync(file)) {
+                        appendFileSync(file, `${(`\n`).repeat(10)}${metadata.raw}`);
+                    } else {
+                        writeFileSync(file, metadata.raw);
+                    }
+                }
+                metadata.text = metadata.raw;
+            }
+
+            if (uploads?.JSON) {
+                const eDestination = settings.GlobalSettings.ArchiveSettings.JSONDirectory;
+                if (eDestination) {
+                    const file = (`${eDestination}/${metadata.name}_${metadata.tracking}.json`).replace(/[\\:*?"<>|]/g, "_").replace(/\s+/g, " ").trim();
+                    if (!existsSync(eDestination)) { mkdirSync(eDestination, { recursive: true }); }
+                    writeFileSync(file, JSON.stringify(GetCleanedEvent(event), null, 2));
+                }
+                metadata.json = JSON.stringify(GetCleanedEvent(event), null, 2);
+            }
+
+            if (notifyServer?.Enabled && notify?.Enabled && notify?.Topic) {
+                let buttons = [];
+                const auth = notifyServer?.Credentials?.Username && notifyServer?.Credentials?.Password ? { username: notifyServer?.Credentials?.Username, password: notifyServer?.Credentials?.Password } : undefined;
+                if (notifyServer?.MediaStorage?.EAS) {
+                    if (metadata.eas) {
+                        buttons.push({
+                            "action": "view",
+                            "label": "Listen",
+                            "url": `${notifyServer?.MediaStorage?.EAS}/${metadata.name}_${metadata.status}_${metadata.tracking}.wav`,
+                        })
+                    }
+                }
+                if (metadata.json) {
+                    buttons.push({
+                        "action": "view",
+                        "label": "View JSON",
+                        "url": `${notifyServer?.MediaStorage?.JSON}/${metadata.name}_${metadata.tracking}.json`,
+                    })
+                }
+                if (metadata.text) {
+                    buttons.push({
+                        "action": "view",
+                        "label": "View Text",
+                        "url": `${notifyServer?.MediaStorage?.TEXT}/${metadata.name}_${metadata.tracking}.txt`,
+                    })
+                }
+                if (metadata.attachments?.length > 0 && metadata.attachments.find(a => a.name === "Image: Graphic")) {
+                    buttons.push({
+                        "action": "view",
+                        "label": "View Image",
+                        "url": metadata.attachments.find(a => a.name === "Image: Graphic").link,
+                    })
+                }
+                await CreateHttp({
+                    url: `${notifyServer?.Server?.replace(/\/$/, "")}/${notify.Topic}`,
+                    timeout: 15_000,
+                    method: "PUT",
+                    ...(auth && { auth }),
+                    headers: {
+                        "Title": `${metadata.name} (${metadata.status})`,
+                        "Tags":  properties.parameters.tags?.join(",") ?? "N/A",
+                        "Priority": notify?.Priority ?? "5",
+                        ... (buttons.length > 0 && { "Actions": JSON.stringify(buttons) }),
+                    },
+                    body: GetStringText(event)
+                })
+            }
+
+            if (webhook?.Enabled && webhook?.Destination) {
+                const isRatelimited = SetTimeoutAction({ identifier: webhook.Destination, interval: (webhook.Ratelimit ?? 2) * 2, max: (webhook.Ratelimit ?? 2), addTime: true })
+                const form = new FormData();
+                const embed = {
+                    title: `${metadata.name} (${metadata.status})`,
+                    description: GetEmebedText(event),
+                    fields: [],
+                    color: 16711680,
+                    timestamp: new Date().toISOString(),
+                    footer: { text: webhook.Title ?? `AtmosphericX` }
+                };
+
+                if (isRatelimited.limited) { return } 
+
+
+                if (metadata.description && !metadata.expired) {
+                    if (metadata.description.length > 900) {   
+                        metadata.description = metadata.description.substring(0, 900) + "\n\n[Message truncated due to length]";
+                    }
+                    embed.fields.push({
+                        name: "Description", 
+                        value: metadata.description ? '```' + '\n' + metadata.description.split('\n').map(l => l.trim()).filter(Boolean).join('\n') + '\n' + '```' : ""
+                    });
+                }
+
+
+                if (metadata.attachments?.length > 0) {
+                    metadata.attachments = metadata.attachments.slice(0, 5);
+                    embed.fields.push({
+                        name: "Attachments", 
+                        value: metadata.attachments.map(attachment => `- [${attachment.name.length > 45 ? attachment.name.substring(0, 45) + '...' : attachment.name}](${attachment.link})`).join('\n')
+                    });
+                }
+
+                if (uploads?.TEXT) { 
+                    form.append("fUpload", new Blob([Buffer.from(metadata.text)], {type: "application/text"}), `${properties.event}_${properties.status}_${properties.metadata.tracking}.txt`)
+                }
+
+                if (uploads?.JSON) { 
+                    form.append("fUpload2", new Blob([Buffer.from(metadata.json)], {type: "application/json"}), `${properties.event}_${properties.status}_${properties.metadata.tracking}.json`)
+                }
+
+                if (uploads?.EAS) { 
+                    if (metadata.eas) {
+                        const file = readFileSync(metadata.eas)
+                        form.append("fEas", new Blob([Buffer.from(file)], { type: "audio/mpeg" }), `${properties.event}_${properties.status}_${properties.metadata.tracking}_eas.mp3`)
+                    }
+                }
+
+                form.append("payload_json", JSON.stringify({
+                    username: webhook.Title ?? "AtmosphericX",
+                    content: webhook.Message ?? "",
+                    embeds: [embed]
+                }));
+
+                await CreateHttp({
+                    url: webhook.Destination,
+                    timeout: 15e3,
+                    method: `POST`,
+                    body: form
+                })
+            }
+        }
+    }
+    SetDebug({ title: `CreateActions`, message: `${Math.round(performance.now() - tick)}ms` })
+}

package/src/@manager/{manager.mkEvent.ts → MakeEvent.ts}

@@ -17,44 +17,47 @@
 
 */
 
-import { setEventEmit } from "../@modules/@utilities/utilities.setEventEmit";
-import { TypeEvent } from "../@types/type.event";
+import { TypeEvent } from "../@types/Event";
+import { TypeSettings } from "../@types/Settings";
+import { EnumGlobalFilter } from "../@enums/GlobalFilter";
 import { bootstrap } from "../bootstrap"
-import { setHash } from "./manager.setHash";
-import { updateWebhooks } from "./manager.updateWebhooks";
-import { updateNode } from "./manager.updateNodes";
-import { TypeSettings } from "../@types/types.settings";
+import { SetHash } from "./SetHash";
+import { CreateActions } from "./CreateActions";
+import { UpdateNode } from "./UpdateNode";
+import { SetEventEmit } from "../@modules/@utilities/SetEventEmit";
+import { SetTimeoutAction } from "../@modules/@utilities/SetTimeoutAction";
 
-export const mkEvent = async (event: TypeEvent): Promise<void> => {
+export const MakeEvent = async (event: TypeEvent): Promise<void> => {
     const settings = bootstrap.settings as TypeSettings;
     const features = bootstrap.cache.events.features;
-    const map = new Map<string, typeof features[0]>();
-    
-    for (const f of features) {
-        const key = f?.properties?.metadata?.tracking;
-        if (!key) continue;
-        map.set(key, f);
-    }
-    
+ 
     const getHash = event.properties.metadata.hash;
     const getTracking = event.properties.metadata.tracking;
     const isEntry = bootstrap.cache.hashes?.find(hash => hash.tracking === getTracking)
     const isHashed = isEntry?.hashes?.includes(getHash) ?? false;
-    const getFeature = map.get(getTracking);
-    
+    const getFeature = features.find(feature => feature.properties.metadata.tracking === getTracking);    
+   
     if (isHashed || event.properties.status_metadata.is_expired) return
-    await setHash(event, isEntry)
-    const isFilteredLocation = await updateNode(event).then(() => event.properties.metadata.filtered_proximity);
-    if (!isFilteredLocation && settings.GlobalSettings.EventFiltering.NodeLocationFiltering) { return }
+    SetHash(event, isEntry)
+    
+    await UpdateNode(event);
+    const isNodeFiltering = settings.GlobalSettings.EventFiltering.NodeLocationFiltering
+    if (isNodeFiltering && !event.properties.metadata.filtered_proximity && !EnumGlobalFilter.includes(event.properties.event.toLowerCase())) { 
+        return
+    }
+    
+    const isRatelimited = SetTimeoutAction({ identifier: getTracking, interval: 1, max: 1, addTime: true })
+    if (!isRatelimited.limited) {
+        SetEventEmit({
+            event: `onEventStatus`,
+            metadata: {
+                type: getFeature ? `Updated` : `New`,
+                event: event
+            },
+            message: `[${getFeature ? 'Updated' : 'New'}] ${event.properties.event} (${event.properties.status}) (${event.properties.metadata.tracking})`
+        })
+    }
 
-    setEventEmit({
-        event: `onEventStatus`,
-        metadata: {
-            type: getFeature ? `Updated` : `New`,
-            event: event
-        },
-        message: `[${getFeature ? 'Updated' : 'New'}] ${event.properties.event} (${event.properties.status}) (${event.properties.metadata.tracking})`
-    })
     if (settings.GlobalSettings.EventManagement) {
         if (event.properties.status_metadata.is_issued || event.properties.status_metadata.is_updated) {
             if (getFeature) { 
@@ -67,7 +70,7 @@ export const mkEvent = async (event: TypeEvent): Promise<void> => {
                 const iLocations = event.properties?.locations?.split(";").map((l: string) => l.trim()) ?? [];
                 const iUgc = event.properties?.geocode?.ugc ?? [];
     
-                const mHistory = [...cHistory, ...iHistory].filter((v, i, a) => a.indexOf(v) === i);
+                const mHistory = [...cHistory, ...iHistory].filter((v, i, a) => a.indexOf(v) === i).filter((v, i, a) => a.findIndex(h => h.description === v.description && h.issued === v.issued) === i);
                 const mLocations = [...cLocations, ...iLocations].filter((v, i, a) => a.indexOf(v) === i).join('; ');
                 const mUgc = [...cUgc, ...iUgc].filter((v, i, a) => a.indexOf(v) === i);
     
@@ -86,10 +89,11 @@ export const mkEvent = async (event: TypeEvent): Promise<void> => {
                         },
                     }
                 };
+                await CreateActions(bootstrap.cache.events.features[getIndex])
             } else { 
                 features.push(event)
+                await CreateActions(event)
             }
         }
     }
-    updateWebhooks(event)
 }

package/src/@manager/RemoveEvent.ts

@@ -0,0 +1,70 @@
+/*
+              _                             _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ V / 
+       / /\ \| __| '_ ` _ \ / _ \/ __| '_ \| '_ \ / _ \ '__| |/ __| > <  
+      / ____ \ |_| | | | | | (_) \__ \ |_) | | | |  __/ |  | | (__ / . \ 
+     /_/    \_\__|_| |_| |_|\___/|___/ .__/|_| |_|\___|_|  |_|\___/_/ \_\
+                                     | |                            
+                                     |_|                                                                                                                
+
+    Created with ♥ by the AtmosphericX Team (KiyoWx, StarflightWx, & CJ Ziegler)
+    Discord: https://atmosphericx-discord.scriptkitty.cafe
+    Ko-Fi: https://ko-fi.com/k3yomi
+    Documentation: http://localhost/documentation | https://atmosphericx.scriptkitty.cafe/documentation
+
+    Internal Package: @atmosx/event-product-parser
+
+*/
+
+import { TypeEvent } from "../@types/Event";
+import { EnumStrings } from "../@enums/Strings";
+import { bootstrap } from "../bootstrap"
+import { SetEventEmit } from "../@modules/@utilities/SetEventEmit";
+import { SetTimeoutAction } from "../@modules/@utilities/SetTimeoutAction";
+import { CreateActions } from "./CreateActions";
+
+
+export const RemoveEvent = async (event: TypeEvent, isTimeBasedExpiration: boolean):Promise<void> => {
+    const gTracking = event.properties.metadata.tracking;
+    const isTrackingEventLogged = bootstrap.cache.events.features
+        .find(f => f?.properties?.metadata?.tracking === gTracking);
+    const isStatement = event.properties.status_metadata.is_statement;
+
+    if (isTrackingEventLogged) { 
+        event.properties.expires = new Date().toISOString();
+        event.properties.status = `Expired`;
+        event.properties.status_metadata.is_expired = true;
+
+        const description = isTimeBasedExpiration ? EnumStrings.cancellation
+            .replace(`{SENDER}`, event.properties.geocode.office.name)
+            .replace(`{EVENT}`, event.properties.event) : event.properties.description
+        event.properties.description = description; 
+        event.properties.metadata.raw = isTimeBasedExpiration ? description : event.properties.metadata.raw;
+        event.properties.metadata.history.push({
+            description: isTimeBasedExpiration ? description : event.properties.description,
+            issued: event.properties.expires,
+            status: event.properties.status
+        })
+
+        bootstrap.cache.events.features
+            .splice(bootstrap.cache.events.features.indexOf(isTrackingEventLogged), 1);
+        bootstrap.cache.hashes = bootstrap.cache.hashes
+            .filter(hash => hash.tracking !== gTracking);
+
+        if (!isStatement) { 
+            SetEventEmit({
+                event: `onEventStatus`,
+                metadata: { type: `Removed`, event: event },
+                message: `[Removed] ${event.properties.event} (${event.properties.status}) (${gTracking})`
+            })
+            await CreateActions(event)
+        }
+        SetTimeoutAction({ identifier: gTracking, expire: true })
+    }
+    SetEventEmit({
+        event: `onEventCache`,
+        metadata: bootstrap.cache.events,
+        limited: true
+    })
+}

package/src/@manager/{manager.setHash.ts → SetHash.ts}

@@ -17,21 +17,20 @@
 
 */
 
-import { TypeEvent } from "../@types/type.event";
-import { TypeHash } from "../@types/types.hash"
+import { TypeEvent } from "../@types/Event";
+import { TypeHash } from "../@types/Hash"
 import { bootstrap } from "../bootstrap"
 
-
-export const setHash = async (event: TypeEvent, entry: TypeHash): Promise<void> => {
-    if (entry) {
-        entry.hashes.push(event.properties.metadata.hash);
-        entry.expires = event.properties.expires;
-    } else { 
+export const SetHash = (event: TypeEvent, entry: TypeHash): void => {
+    if (!entry) {
         bootstrap.cache.hashes.push({
             tracking: event.properties.metadata.tracking,
             hashes: [event.properties.metadata.hash],
             expires: event.properties.expires
         });
+        return;
     }
-    
+
+    entry.hashes.push(event.properties.metadata.hash);
+    entry.expires = event.properties.expires;
 }

package/src/@manager/{manager.updateEvents.ts → UpdateEvents.ts}

@@ -17,19 +17,19 @@
 
 */
 
-import { getFormattedTime } from "../@modules/@utilities/utilities.getFormattedTime";
-import { TypeEvent } from "../@types/type.event";
+import { TypeEvent } from "../@types/Event";
 import { bootstrap } from "../bootstrap"
-import { rmEvent } from "./manager.rmEvent";
+import { SetEventEmit } from "../@modules/@utilities/SetEventEmit";
+import { RemoveEvent } from "./RemoveEvent";
 
-
-export const updateEvents = async (selectedEvent?: TypeEvent): Promise<void> => {
+export const UpdateEvents = async (selectedEvent?: TypeEvent): Promise<void> => {
     const events = bootstrap.cache.events.features;
-    async function update(evt: TypeEvent) {
-        if (new Date(evt.properties.expires) < new Date()) {
-            rmEvent(evt);
+    async function update(event: TypeEvent) {
+        if (new Date(event.properties.expires) < new Date()) {
+            SetEventEmit({ event: `onExpiredProduct`, metadata: event })
+            await RemoveEvent(event, true)
         }
     }
-    if (!selectedEvent) { await Promise.all(events.map(async (evt) => { await update(evt) })) } 
+    if (!selectedEvent) { await Promise.all(events.map(async (event) => { await update(event) })) } 
     if (selectedEvent) { await update(selectedEvent) }
 }

package/src/@manager/{manager.updateNodes.ts → UpdateNode.ts}

@@ -17,34 +17,41 @@
 
 */
 
-import { getEventNodes } from "../@building/building.polygon";
-import { setEventEmit } from "../@modules/@utilities/utilities.setEventEmit";
-import { TypeEvent } from "../@types/type.event";
+import { TypeEvent } from "../@types/Event";
 import { bootstrap } from "../bootstrap"
+import { GetEventNodes } from "../@building/GetEventNodes";
+import { SetEventEmit } from "../@modules/@utilities/SetEventEmit";
 
-
-export const updateNode = async (selectedEvent?: TypeEvent): Promise<void> => {
+export const UpdateNode = async (selectedEvent?: TypeEvent): Promise<void> => {
     const events = bootstrap.cache.events.features;
     const ttl = bootstrap.settings.GlobalSettings.NodeTTL * 1e3;
     let total = 0;
 
-    async function update(evt: TypeEvent) {
+    const TTLEvents = selectedEvent ? [selectedEvent] : events.filter((evt) => {
         const lastUpdate = evt?.properties?.metadata?.updated ?? null;
-        if (lastUpdate != null && (Date.now() - lastUpdate) < ttl) {
-            return evt;
-        }
-        const node = await getEventNodes(evt);
+        return lastUpdate == null || (Date.now() - lastUpdate) >= ttl;
+    });
+
+    if (TTLEvents.length === 0) return;
+
+    async function update(evt: TypeEvent) {
+        const node = await GetEventNodes(evt);
         if (node.nodes.length > 0) {
-            total++
+            total++;
         }
-        evt.properties.metadata.nodes = node.nodes
-        evt.properties.metadata.filtered_proximity = node.filtered
-        evt.properties.metadata.updated = node.updated
+        evt.properties.metadata.nodes = node.nodes;
+        evt.properties.metadata.filtered_proximity = node.filtered;
+        evt.properties.metadata.updated = node.updated;
+    }
+
+    const concurrency = 4;
+    for (let index = 0; index < TTLEvents.length; index += concurrency) {
+        const batch = TTLEvents.slice(index, index + concurrency);
+        await Promise.all(batch.map((evt) => update(evt)));
     }
-    if (!selectedEvent) { await Promise.all(events.map(async (evt) => { await update(evt) })) } 
-    if (selectedEvent) { await update(selectedEvent) }
+
     if (total > 0) {
-        setEventEmit({
+        SetEventEmit({
             event: `onNodeUpdate`,
             metadata: {
                 type: `global-update`,

package/src/@modules/@database/{database.cache.ts → GetCachedEvents.ts}

@@ -17,19 +17,20 @@
 
 */
 
-import { TypeSettings } from "../../@types/types.settings"
+import { TypeSettings } from "../../@types/Settings"
 import { bootstrap } from '../../bootstrap'
-import { setWarning } from '../@utilities/utilities.setWarning';
-import { createEvent } from '../../@building/building.create';
+import { SetWarning } from '../@utilities/SetWarning';
+import { CreateEvent } from '../../@building/CreateEvent';
+import { ValidateEvents } from "../../@building/ValidateEvents";
 
-export const getCachedEvents = async (): Promise<void> => {
+export const GetCachedEvents = async (): Promise<void> => {
     try { 
         const settings = bootstrap.settings as TypeSettings;
         const tick = performance.now();
         if (settings.NOAAWeatherWireServiceSettings.CacheSettings.Enabled) {
             const max = settings.NOAAWeatherWireServiceSettings.CacheSettings.MaxRetentionHistory ?? 500;
             const get = await bootstrap.database.prepare(`SELECT * FROM stanzas ORDER BY rowid DESC LIMIT ?`).all(max) as { rowid: number; stanza: string }[];
-            setWarning({ message: `Fetched ${get.length} cached events from the database in ${Math.floor(performance.now() - tick)} ms` })
+            SetWarning({ message: `Fetched ${get.length} cached stanzas from the database in ${Math.floor(performance.now() - tick)} ms` })
             let events = get.map((row) => JSON.parse(row.stanza))
                 .filter(stanza => {
                     if (!stanza) { return }
@@ -39,10 +40,11 @@ export const getCachedEvents = async (): Promise<void> => {
                     return !isSkippable
                 });
             events = events.sort((a, b) => b.issued - a.issued)
-            await Promise.all(events.map(event => createEvent(event)))
-            setWarning({ message: `Processed ${events.length} cached events in ${Math.floor(performance.now() - tick)} ms` })
+            await Promise.all(events.map(event => CreateEvent(event, true)))
+            SetWarning({ message: `Processed ${events.length} cached stanzas in ${Math.floor(performance.now() - tick)} ms` })
+            await ValidateEvents(bootstrap.cache.processed)
         }
     } catch (error) {
-        setWarning({ message: `An error occurred while fetching cached events: ${error.message} -> ${error.stack}` })
+        SetWarning({ message: `An error occurred while fetching cached stanzas: ${error.message} -> ${error.stack}` })
     }
 }