gtfs 4.18.2 → 4.18.4

package/dist/bin/gtfsrealtime-update.js

@@ -583,6 +583,61 @@ var serviceAlertInformedEntities = {
 
 // src/lib/db.ts
 import Database from "better-sqlite3";
+
+// src/lib/errors.ts
+var GtfsError = class extends Error {
+  code;
+  category;
+  isOperational;
+  statusCode;
+  details;
+  constructor(message, options) {
+    super(message, { cause: options.cause });
+    this.name = "GtfsError";
+    this.code = options.code;
+    this.category = options.category;
+    this.isOperational = options.isOperational ?? true;
+    this.statusCode = options.statusCode;
+    this.details = options.details;
+  }
+};
+function isGtfsError(error) {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  const candidate = error;
+  return candidate.name === "GtfsError" && typeof candidate.message === "string" && typeof candidate.code === "string" && typeof candidate.category === "string" && typeof candidate.isOperational === "boolean";
+}
+function toGtfsError(error, fallback) {
+  if (isGtfsError(error)) {
+    return error;
+  }
+  return new GtfsError(fallback.message, {
+    ...fallback,
+    cause: error
+  });
+}
+function addImportError(report, error) {
+  report.errors.push(error);
+  report.errorCountsByCode[error.code] = (report.errorCountsByCode[error.code] ?? 0) + 1;
+}
+function formatGtfsError(error, options = { verbosity: "developer" }) {
+  if (!isGtfsError(error)) {
+    const message = error instanceof Error ? error.message : String(error);
+    return options.verbosity === "user" ? message : `UNKNOWN_ERROR: ${message}`;
+  }
+  if (options.verbosity === "user") {
+    return error.message;
+  }
+  return [
+    `${error.code}: ${error.message}`,
+    `category=${error.category}`,
+    error.statusCode !== void 0 ? `statusCode=${error.statusCode}` : null,
+    error.details ? `details=${JSON.stringify(error.details)}` : null
+  ].filter(Boolean).join(" | ");
+}
+
+// src/lib/db.ts
 var dbs = {};
 function setupDb(sqlitePath) {
   const db = new Database(untildify(sqlitePath));
@@ -611,11 +666,19 @@ function openDb(config = null) {
     return dbs[filename];
   }
   if (Object.keys(dbs).length > 1) {
-    throw new Error(
-      "Multiple databases open, please specify which one to use."
+    throw new GtfsError(
+      "Multiple databases open, please specify which one to use.",
+      {
+        code: "GTFS_DB_OPERATION_FAILED" /* GTFS_DB_OPERATION_FAILED */,
+        category: "database" /* DATABASE */,
+        details: { openDatabaseCount: Object.keys(dbs).length }
+      }
     );
   }
-  throw new Error("Unable to find database connection.");
+  throw new GtfsError("Unable to find database connection.", {
+    code: "GTFS_DB_OPERATION_FAILED" /* GTFS_DB_OPERATION_FAILED */,
+    category: "database" /* DATABASE */
+  });
 }
 
 // src/lib/geojson-utils.ts
@@ -641,12 +704,21 @@ import sqlString from "sqlstring-sqlite";
 import Long from "long";
 function validateConfigForImport(config) {
   if (!config.agencies || config.agencies.length === 0) {
-    throw new Error("No `agencies` specified in config");
+    throw new GtfsError("No `agencies` specified in config", {
+      code: "GTFS_CONFIG_INVALID" /* GTFS_CONFIG_INVALID */,
+      category: "config" /* CONFIG */,
+      details: { field: "agencies" }
+    });
   }
   for (const [index, agency2] of config.agencies.entries()) {
     if (!agency2.path && !agency2.url) {
-      throw new Error(
-        `No Agency \`url\` or \`path\` specified in config for agency index ${index}.`
+      throw new GtfsError(
+        `No Agency \`url\` or \`path\` specified in config for agency index ${index}.`,
+        {
+          code: "GTFS_CONFIG_INVALID" /* GTFS_CONFIG_INVALID */,
+          category: "config" /* CONFIG */,
+          details: { agencyIndex: index }
+        }
       );
     }
   }
@@ -743,7 +815,16 @@ async function fetchGtfsRealtimeData(type, task) {
         signal: task.downloadTimeout ? AbortSignal.timeout(task.downloadTimeout) : void 0
       });
       if (response.status !== 200) {
-        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        throw new GtfsError(`HTTP ${response.status}: ${response.statusText}`, {
+          code: "GTFS_DOWNLOAD_HTTP" /* GTFS_DOWNLOAD_HTTP */,
+          category: "download" /* DOWNLOAD */,
+          statusCode: response.status,
+          details: {
+            url: urlConfig.url,
+            status: response.status,
+            statusText: response.statusText
+          }
+        });
       }
       const buffer = await response.arrayBuffer();
       const message = GtfsRealtimeBindings.transit_realtime.FeedMessage.decode(
@@ -760,17 +841,27 @@ async function fetchGtfsRealtimeData(type, task) {
       });
       return feedMessage;
     } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
+      const gtfsError = toGtfsError(error, {
+        message: error instanceof Error ? error.message : String(error),
+        code: "GTFS_DOWNLOAD_FAILED" /* GTFS_DOWNLOAD_FAILED */,
+        category: "download" /* DOWNLOAD */,
+        details: { type, url: urlConfig.url }
+      });
       if (attempt === MAX_RETRIES) {
         if (task.ignoreErrors) {
           task.logError(
-            `Failed to fetch ${type} after ${MAX_RETRIES} attempts: ${errorMessage}`
+            `Failed to fetch ${type} after ${MAX_RETRIES} attempts: ${gtfsError.message}`
           );
+          if (task.report) {
+            addImportError(task.report, gtfsError);
+          }
           return null;
         }
-        throw error;
+        throw gtfsError;
       }
-      task.logWarning(`Attempt ${attempt} failed for ${type}: ${errorMessage}`);
+      task.logWarning(
+        `Attempt ${attempt} failed for ${type}: ${gtfsError.message}`
+      );
       await new Promise(
         (resolve) => setTimeout(resolve, RETRY_DELAY * attempt)
       );
@@ -977,8 +1068,9 @@ async function updateGtfsRealtime(initialConfig) {
     );
     removeExpiredRealtimeData(config);
     await mapSeries(config.agencies, async (agency2) => {
+      let task;
       try {
-        const task = {
+        task = {
           realtimeAlerts: agency2.realtimeAlerts,
           realtimeTripUpdates: agency2.realtimeTripUpdates,
           realtimeVehiclePositions: agency2.realtimeVehiclePositions,
@@ -994,11 +1086,19 @@ async function updateGtfsRealtime(initialConfig) {
         };
         await updateGtfsRealtimeData(task);
       } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
+        const gtfsError = toGtfsError(error, {
+          message: error instanceof Error ? error.message : String(error),
+          code: "GTFS_DB_OPERATION_FAILED" /* GTFS_DB_OPERATION_FAILED */,
+          category: "database" /* DATABASE */,
+          details: { sqlitePath: task?.sqlitePath ?? config.sqlitePath }
+        });
         if (config.ignoreErrors) {
-          logError(config)(errorMessage);
+          logError(config)(formatGtfsError(gtfsError));
+          if (task?.report) {
+            addImportError(task.report, gtfsError);
+          }
         } else {
-          throw error;
+          throw gtfsError;
         }
       }
     });
@@ -1012,11 +1112,26 @@ async function updateGtfsRealtime(initialConfig) {
     );
   } catch (error) {
     if (error.code === "SQLITE_CANTOPEN") {
-      logError(config)(
-        `Unable to open sqlite database "${config.sqlitePath}" defined as \`sqlitePath\` config.json. Ensure the parent directory exists or remove \`sqlitePath\` from config.json.`
+      const dbOpenError = new GtfsError(
+        `Unable to open sqlite database "${config.sqlitePath}" defined as \`sqlitePath\` config.json. Ensure the parent directory exists or remove \`sqlitePath\` from config.json.`,
+        {
+          code: "DB_OPEN_FAILED" /* DB_OPEN_FAILED */,
+          category: "database" /* DATABASE */,
+          details: {
+            sqlitePath: config.sqlitePath,
+            dbCode: error.code
+          },
+          cause: error
+        }
       );
+      logError(config)(dbOpenError.message);
+      throw dbOpenError;
     }
-    throw error;
+    throw toGtfsError(error, {
+      message: error instanceof Error ? error.message : String(error),
+      code: "GTFS_DB_OPERATION_FAILED" /* GTFS_DB_OPERATION_FAILED */,
+      category: "database" /* DATABASE */
+    });
   }
 }