gtfs 4.18.3 → 4.18.5

package/dist/bin/gtfs-import.js

@@ -101,7 +101,8 @@ async function getConfig(argv2) {
   } catch (error) {
     if (error instanceof SyntaxError) {
       throw new Error(
-        `Cannot parse configuration file. Check to ensure that it is valid JSON. Error: ${error.message}`
+        `Cannot parse configuration file. Check to ensure that it is valid JSON. Error: ${error.message}`,
+        { cause: error }
       );
     }
     throw error;
@@ -114,7 +115,8 @@ async function unzip(zipfilePath, exportPath) {
     await zip.close();
   } catch (error) {
     throw new Error(
-      `Failed to extract zip file: ${error instanceof Error ? error.message : "Unknown error"}`
+      `Failed to extract zip file: ${error instanceof Error ? error.message : "Unknown error"}`,
+      { cause: error }
     );
   }
 }
@@ -4108,6 +4110,73 @@ var vehicles = {
 
 // 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 createImportReport() {
+  return {
+    errors: [],
+    warnings: [],
+    errorCountsByCode: {},
+    warningCountsByCode: {}
+  };
+}
+function addImportError(report, error) {
+  report.errors.push(error);
+  report.errorCountsByCode[error.code] = (report.errorCountsByCode[error.code] ?? 0) + 1;
+}
+function addImportWarning(report, warning) {
+  report.warnings.push(warning);
+  report.warningCountsByCode[warning.code] = (report.warningCountsByCode[warning.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));
@@ -4136,22 +4205,39 @@ 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 */
+  });
 }
 function closeDb(db = null) {
   if (Object.keys(dbs).length === 0) {
-    throw new Error(
-      "No database connection. Call `openDb(config)` before using any methods."
+    throw new GtfsError(
+      "No database connection. Call `openDb(config)` before using any methods.",
+      {
+        code: "GTFS_DB_OPERATION_FAILED" /* GTFS_DB_OPERATION_FAILED */,
+        category: "database" /* DATABASE */
+      }
     );
   }
   if (!db) {
     if (Object.keys(dbs).length > 1) {
-      throw new Error(
-        "Multiple database connections. Pass the db you want to close as a parameter to `closeDb`."
+      throw new GtfsError(
+        "Multiple database connections. Pass the db you want to close as a parameter to `closeDb`.",
+        {
+          code: "GTFS_DB_OPERATION_FAILED" /* GTFS_DB_OPERATION_FAILED */,
+          category: "database" /* DATABASE */,
+          details: { openDatabaseCount: Object.keys(dbs).length }
+        }
       );
     }
     db = dbs[Object.keys(dbs)[0]];
@@ -4191,12 +4277,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 }
+        }
       );
     }
   }
@@ -4303,7 +4398,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(
@@ -4320,17 +4424,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)
       );
@@ -4505,33 +4619,64 @@ async function updateGtfsRealtimeData(task) {
 }
 
 // src/lib/import-gtfs.ts
+function reportTaskError(task, error) {
+  if (task.report) {
+    addImportError(task.report, error);
+  }
+}
 var getTextFiles = async (folderPath) => {
   const files = await readdir(folderPath);
   return files.filter((filename) => filename.slice(-3) === "txt");
 };
 var downloadGtfsFiles = async (task) => {
   if (!task.url) {
-    throw new Error("No `url` specified in config");
+    throw new GtfsError("No `url` specified in config", {
+      code: "GTFS_CONFIG_INVALID" /* GTFS_CONFIG_INVALID */,
+      category: "config" /* CONFIG */
+    });
   }
   task.log(`Downloading GTFS from ${task.url}`);
   task.path = `${task.downloadDir}/gtfs.zip`;
-  const response = await fetch(task.url, {
-    method: "GET",
-    headers: task.headers || {},
-    signal: task.downloadTimeout ? AbortSignal.timeout(task.downloadTimeout) : void 0
-  });
-  if (response.status !== 200) {
-    throw new Error(
-      `Unable to download GTFS from ${task.url}. Got status ${response.status}.`
-    );
+  try {
+    const response = await fetch(task.url, {
+      method: "GET",
+      headers: task.headers || {},
+      signal: task.downloadTimeout ? AbortSignal.timeout(task.downloadTimeout) : void 0
+    });
+    if (response.status !== 200) {
+      throw new GtfsError(
+        `Unable to download GTFS from ${task.url}. Got status ${response.status}.`,
+        {
+          code: "GTFS_DOWNLOAD_HTTP" /* GTFS_DOWNLOAD_HTTP */,
+          category: "download" /* DOWNLOAD */,
+          statusCode: response.status,
+          details: {
+            url: task.url,
+            status: response.status,
+            statusText: response.statusText
+          }
+        }
+      );
+    }
+    const buffer = await response.arrayBuffer();
+    await writeFile(task.path, Buffer.from(buffer));
+    task.log("Download successful");
+  } catch (error) {
+    throw toGtfsError(error, {
+      message: `Unable to download GTFS from ${task.url}.`,
+      code: "GTFS_DOWNLOAD_FAILED" /* GTFS_DOWNLOAD_FAILED */,
+      category: "download" /* DOWNLOAD */,
+      details: { url: task.url }
+    });
   }
-  const buffer = await response.arrayBuffer();
-  await writeFile(task.path, Buffer.from(buffer));
-  task.log("Download successful");
 };
 var extractGtfsFiles = async (task) => {
   if (!task.path) {
-    throw new Error("No `path` specified in config");
+    throw new GtfsError("No `path` specified in config", {
+      code: "GTFS_CONFIG_INVALID" /* GTFS_CONFIG_INVALID */,
+      category: "config" /* CONFIG */,
+      details: { field: "path" }
+    });
   }
   const gtfsPath = untildify(task.path);
   task.log(`Importing static GTFS from ${task.path}\r`);
@@ -4543,19 +4688,34 @@ var extractGtfsFiles = async (task) => {
         const files = await readdir(task.downloadDir);
         const folders = files.filter((filename) => !["__MACOSX"].includes(filename)).map((filename) => path2.join(task.downloadDir, filename)).filter((source) => lstatSync(source).isDirectory());
         if (folders.length > 1) {
-          throw new Error(
-            `More than one subfolder found in zip file at \`${task.path}\`. Ensure that .txt files are in the top level of the zip file, or in a single subdirectory.`
+          throw new GtfsError(
+            `More than one subfolder found in zip file at \`${task.path}\`. Ensure that .txt files are in the top level of the zip file, or in a single subdirectory.`,
+            {
+              code: "GTFS_ZIP_INVALID" /* GTFS_ZIP_INVALID */,
+              category: "zip" /* ZIP */,
+              details: { path: task.path, folderCount: folders.length }
+            }
           );
         } else if (folders.length === 0) {
-          throw new Error(
-            `No .txt files found in \`${task.path}\`. Ensure that .txt files are in the top level of the zip file, or in a single subdirectory.`
+          throw new GtfsError(
+            `No .txt files found in \`${task.path}\`. Ensure that .txt files are in the top level of the zip file, or in a single subdirectory.`,
+            {
+              code: "GTFS_ZIP_INVALID" /* GTFS_ZIP_INVALID */,
+              category: "zip" /* ZIP */,
+              details: { path: task.path }
+            }
           );
         }
         const subfolderName = folders[0];
         const directoryTextFiles = await getTextFiles(subfolderName);
         if (directoryTextFiles.length === 0) {
-          throw new Error(
-            `No .txt files found in \`${task.path}\`. Ensure that .txt files are in the top level of the zip file, or in a single subdirectory.`
+          throw new GtfsError(
+            `No .txt files found in \`${task.path}\`. Ensure that .txt files are in the top level of the zip file, or in a single subdirectory.`,
+            {
+              code: "GTFS_ZIP_INVALID" /* GTFS_ZIP_INVALID */,
+              category: "zip" /* ZIP */,
+              details: { path: task.path, subfolderName }
+            }
           );
         }
         await Promise.all(
@@ -4568,15 +4728,27 @@ var extractGtfsFiles = async (task) => {
         );
       }
     } catch (error) {
-      task.logError(error);
-      throw new Error(`Unable to unzip file ${task.path}`);
+      const wrappedError = toGtfsError(error, {
+        message: `Unable to unzip file ${task.path}`,
+        code: "GTFS_ZIP_INVALID" /* GTFS_ZIP_INVALID */,
+        category: "zip" /* ZIP */,
+        details: { path: task.path }
+      });
+      task.logError(formatGtfsError(wrappedError));
+      throw wrappedError;
     }
   } else {
     try {
       await cp(gtfsPath, task.downloadDir, { recursive: true });
-    } catch {
-      throw new Error(
-        `Unable to load files from path \`${gtfsPath}\` defined in configuration. Verify that path exists and contains GTFS files.`
+    } catch (error) {
+      throw new GtfsError(
+        `Unable to load files from path \`${gtfsPath}\` defined in configuration. Verify that path exists and contains GTFS files.`,
+        {
+          code: "GTFS_DOWNLOAD_FAILED" /* GTFS_DOWNLOAD_FAILED */,
+          category: "download" /* DOWNLOAD */,
+          details: { path: gtfsPath },
+          cause: error
+        }
       );
     }
   }
@@ -4671,8 +4843,17 @@ var formatGtfsLine = (line, model, totalLineCount) => {
     if (value === "" || value === void 0 || value === null) {
       formattedLine[name] = null;
       if (required) {
-        throw new Error(
-          `Missing required value in ${filenameBase}.${filenameExtension} for ${name} on line ${lineNumber}.`
+        throw new GtfsError(
+          `Missing required value in ${filenameBase}.${filenameExtension} for ${name} on line ${lineNumber}.`,
+          {
+            code: "GTFS_REQUIRED_FIELD_MISSING" /* GTFS_REQUIRED_FIELD_MISSING */,
+            category: "validation" /* VALIDATION */,
+            details: {
+              file: `${filenameBase}.${filenameExtension}`,
+              line: lineNumber,
+              column: name
+            }
+          }
         );
       }
       continue;
@@ -4680,8 +4861,18 @@ var formatGtfsLine = (line, model, totalLineCount) => {
     if (type === "date") {
       value = value?.toString().replace(/-/g, "");
       if (value.length !== 8) {
-        throw new Error(
-          `Invalid date in ${filenameBase}.${filenameExtension} for ${name} on line ${lineNumber}.`
+        throw new GtfsError(
+          `Invalid date in ${filenameBase}.${filenameExtension} for ${name} on line ${lineNumber}.`,
+          {
+            code: "GTFS_INVALID_DATE" /* GTFS_INVALID_DATE */,
+            category: "validation" /* VALIDATION */,
+            details: {
+              file: `${filenameBase}.${filenameExtension}`,
+              line: lineNumber,
+              column: name,
+              value
+            }
+          }
         );
       }
     } else if (type === "time") {
@@ -4753,11 +4944,32 @@ var importGtfsFiles = async (db, task) => {
               task.logWarning(
                 `Duplicate values for primary key (${primaryColumns.map((column) => column.name).join(", ")}) found in ${filename}. Set the \`ignoreDuplicates\` option to true in config.json to ignore this error`
               );
+              if (task.report) {
+                addImportWarning(task.report, {
+                  code: "GTFS_DUPLICATE_PRIMARY_KEY" /* GTFS_DUPLICATE_PRIMARY_KEY */,
+                  message: `Duplicate values for primary key found in ${filename}.`,
+                  details: {
+                    file: filename,
+                    line: Number(rowNumber) + 1,
+                    columns: primaryColumns.map((column) => column.name)
+                  }
+                });
+              }
             }
             task.logWarning(
               `Check ${filename} for invalid data on line ${rowNumber + 1}.`
             );
-            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 */,
+              details: {
+                file: filename,
+                line: Number(rowNumber) + 1,
+                sqlitePath: task.sqlitePath,
+                dbCode: error.code
+              }
+            });
           }
         }
       });
@@ -4786,12 +4998,20 @@ var importGtfsFiles = async (db, task) => {
               }
             }
           } catch (error) {
+            const gtfsError = toGtfsError(error, {
+              message: error instanceof Error ? error.message : String(error),
+              code: "GTFS_CSV_PARSE_FAILED" /* GTFS_CSV_PARSE_FAILED */,
+              category: "parse" /* PARSE */,
+              details: { file: filename }
+            });
             if (task.ignoreErrors) {
-              const errorMessage = error instanceof Error ? error.message : String(error);
-              task.logError(`Error processing ${filename}: ${errorMessage}`);
+              reportTaskError(task, gtfsError);
+              task.logError(
+                `Error processing ${filename}: ${gtfsError.message}`
+              );
               resolve();
             } else {
-              reject(error);
+              reject(gtfsError);
             }
           }
         });
@@ -4801,15 +5021,21 @@ var importGtfsFiles = async (db, task) => {
               try {
                 insertLines(lines);
               } catch (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: { file: filename, sqlitePath: task.sqlitePath }
+                });
                 if (task.ignoreErrors) {
-                  const errorMessage = error instanceof Error ? error.message : String(error);
                   task.logError(
-                    `Error inserting data for ${filename}: ${errorMessage}`
+                    `Error inserting data for ${filename}: ${gtfsError.message}`
                   );
+                  reportTaskError(task, gtfsError);
                   resolve();
                   return;
                 } else {
-                  reject(error);
+                  reject(gtfsError);
                   return;
                 }
               }
@@ -4820,22 +5046,38 @@ var importGtfsFiles = async (db, task) => {
             );
             resolve();
           } catch (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: { file: filename, sqlitePath: task.sqlitePath }
+            });
             if (task.ignoreErrors) {
-              const errorMessage = error instanceof Error ? error.message : String(error);
-              task.logError(`Error finalizing ${filename}: ${errorMessage}`);
+              task.logError(
+                `Error finalizing ${filename}: ${gtfsError.message}`
+              );
+              reportTaskError(task, gtfsError);
               resolve();
             } else {
-              reject(error);
+              reject(gtfsError);
             }
           }
         });
         parser.on("error", (error) => {
+          const gtfsError = toGtfsError(error, {
+            message: error instanceof Error ? error.message : String(error),
+            code: "GTFS_CSV_PARSE_FAILED" /* GTFS_CSV_PARSE_FAILED */,
+            category: "parse" /* PARSE */,
+            details: { file: filename }
+          });
           if (task.ignoreErrors) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            task.logError(`Parser error for ${filename}: ${errorMessage}`);
+            task.logError(
+              `Parser error for ${filename}: ${gtfsError.message}`
+            );
+            reportTaskError(task, gtfsError);
             resolve();
           } else {
-            reject(error);
+            reject(gtfsError);
           }
         });
         createReadStream(filepath).pipe(stripBomStream()).pipe(parser);
@@ -4844,10 +5086,24 @@ var importGtfsFiles = async (db, task) => {
           if (isValidJSON(data) === false) {
             if (task.ignoreErrors) {
               task.logError(`Invalid JSON in ${filename}`);
+              reportTaskError(
+                task,
+                new GtfsError(`Invalid JSON in ${filename}`, {
+                  code: "GTFS_JSON_INVALID" /* GTFS_JSON_INVALID */,
+                  category: "parse" /* PARSE */,
+                  details: { file: filename }
+                })
+              );
               resolve();
               return;
             } else {
-              reject(new Error(`Invalid JSON in ${filename}`));
+              reject(
+                new GtfsError(`Invalid JSON in ${filename}`, {
+                  code: "GTFS_JSON_INVALID" /* GTFS_JSON_INVALID */,
+                  category: "parse" /* PARSE */,
+                  details: { file: filename }
+                })
+              );
               return;
             }
           }
@@ -4865,23 +5121,37 @@ var importGtfsFiles = async (db, task) => {
             );
             resolve();
           } catch (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: { file: filename, sqlitePath: task.sqlitePath }
+            });
             if (task.ignoreErrors) {
-              const errorMessage = error instanceof Error ? error.message : String(error);
               task.logError(
-                `Error inserting data for ${filename}: ${errorMessage}`
+                `Error inserting data for ${filename}: ${gtfsError.message}`
               );
+              reportTaskError(task, gtfsError);
               resolve();
             } else {
-              reject(error);
+              reject(gtfsError);
             }
           }
         }).catch((error) => {
+          const gtfsError = toGtfsError(error, {
+            message: error instanceof Error ? error.message : String(error),
+            code: "GTFS_CSV_PARSE_FAILED" /* GTFS_CSV_PARSE_FAILED */,
+            category: "parse" /* PARSE */,
+            details: { file: filename }
+          });
           if (task.ignoreErrors) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            task.logError(`Error reading ${filename}: ${errorMessage}`);
+            task.logError(
+              `Error reading ${filename}: ${gtfsError.message}`
+            );
+            reportTaskError(task, gtfsError);
             resolve();
           } else {
-            reject(error);
+            reject(gtfsError);
           }
         });
       } else {
@@ -4892,7 +5162,17 @@ var importGtfsFiles = async (db, task) => {
           resolve();
         } else {
           reject(
-            new Error(`Unsupported file type: ${model.filenameExtension}`)
+            new GtfsError(
+              `Unsupported file type: ${model.filenameExtension}`,
+              {
+                code: "GTFS_UNSUPPORTED_FILE_TYPE" /* GTFS_UNSUPPORTED_FILE_TYPE */,
+                category: "parse" /* PARSE */,
+                details: {
+                  file: filename,
+                  extension: model.filenameExtension
+                }
+              }
+            )
           );
         }
       }
@@ -4904,6 +5184,7 @@ async function importGtfs(initialConfig) {
   const startTime = process.hrtime.bigint();
   const config = setDefaultConfig(initialConfig);
   validateConfigForImport(config);
+  const report = config.includeImportReport ? createImportReport() : void 0;
   try {
     const db = openDb(config);
     const agencyCount = config.agencies.length;
@@ -4931,7 +5212,8 @@ async function importGtfs(initialConfig) {
           currentTimestamp: Math.floor(Date.now() / 1e3),
           log: log(config),
           logWarning: logWarning(config),
-          logError: logError(config)
+          logError: logError(config),
+          report
         };
         if ("url" in agency2) {
           Object.assign(task, { url: agency2.url });
@@ -4946,11 +5228,18 @@ async function importGtfs(initialConfig) {
         await updateGtfsRealtimeData(task);
         await rm2(tempPath, { recursive: true });
       } catch (error) {
+        const wrappedError = toGtfsError(error, {
+          message: error instanceof Error ? error.message : String(error),
+          code: "GTFS_CSV_PARSE_FAILED" /* GTFS_CSV_PARSE_FAILED */,
+          category: "parse" /* PARSE */
+        });
         if (config.ignoreErrors) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          logError(config)(errorMessage);
+          logError(config)(formatGtfsError(wrappedError));
+          if (report) {
+            addImportError(report, wrappedError);
+          }
         } else {
-          throw error;
+          throw wrappedError;
         }
       }
     });
@@ -4964,11 +5253,29 @@ async function importGtfs(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_CSV_PARSE_FAILED" /* GTFS_CSV_PARSE_FAILED */,
+      category: "parse" /* PARSE */
+    });
+  }
+  if (report) {
+    return report;
   }
 }