gtfs 4.17.6 → 4.17.7

package/dist/bin/gtfs-import.js

@@ -13,10 +13,10 @@ import PrettyError from "pretty-error";
 // src/lib/file-utils.ts
 import path from "path";
 import { existsSync } from "fs";
+import { homedir } from "os";
 import { mkdir, readFile, rm } from "fs/promises";
 import { omit, snakeCase } from "lodash-es";
 import sanitize from "sanitize-filename";
-import untildify from "untildify";
 import StreamZip from "node-stream-zip";
 
 // src/lib/log-utils.ts
@@ -70,6 +70,7 @@ function formatError(error) {
 }
 
 // src/lib/file-utils.ts
+var homeDirectory = homedir();
 async function getConfig(argv2) {
   let config;
   let data;
@@ -117,17 +118,17 @@ async function unzip(zipfilePath, exportPath) {
     );
   }
 }
+function untildify(pathWithTilde) {
+  return homeDirectory ? pathWithTilde.replace(/^~(?=$|\/|\\)/, homeDirectory) : pathWithTilde;
+}
 
 // src/lib/import-gtfs.ts
 import path2 from "path";
 import { createReadStream, existsSync as existsSync2, lstatSync } from "fs";
 import { cp, readdir, rename, readFile as readFile2, rm as rm2, writeFile } from "fs/promises";
 import { parse } from "csv-parse";
-import pluralize2 from "pluralize";
 import stripBomStream from "strip-bom-stream";
 import { temporaryDirectory } from "tempy";
-import Timer from "timer-machine";
-import untildify3 from "untildify";
 import mapSeries2 from "promise-map-series";
 
 // src/models/models.ts
@@ -4089,10 +4090,9 @@ var vehicles = {
 
 // src/lib/db.ts
 import Database from "better-sqlite3";
-import untildify2 from "untildify";
 var dbs = {};
 function setupDb(sqlitePath) {
-  const db = new Database(untildify2(sqlitePath));
+  const db = new Database(untildify(sqlitePath));
   db.pragma("journal_mode = OFF");
   db.pragma("synchronous = OFF");
   db.pragma("temp_store = MEMORY");
@@ -4164,7 +4164,6 @@ function isValidJSON(string) {
 }
 
 // src/lib/import-gtfs-realtime.ts
-import pluralize from "pluralize";
 import GtfsRealtimeBindings from "gtfs-realtime-bindings";
 import mapSeries from "promise-map-series";
 import { get } from "lodash-es";
@@ -4220,6 +4219,9 @@ function applyPrefixToValue(value, columnShouldBePrefixed, prefix) {
   }
   return `${prefix}${value}`;
 }
+function pluralize(singularWord, pluralWord, count) {
+  return count === 1 ? singularWord : pluralWord;
+}
 
 // src/lib/import-gtfs-realtime.ts
 async function fetchGtfsRealtimeData(urlConfig, task) {
@@ -4456,7 +4458,7 @@ var extractGtfsFiles = async (task) => {
   if (!task.path) {
     throw new Error("No `path` specified in config");
   }
-  const gtfsPath = untildify3(task.path);
+  const gtfsPath = untildify(task.path);
   task.log(`Importing GTFS from ${task.path}\r`);
   if (path2.extname(gtfsPath) === ".zip") {
     try {
@@ -4708,7 +4710,12 @@ var importGtfsFiles = (db, task) => mapSeries2(
             }
           }
         } catch (error) {
-          reject(error);
+          if (task.ignoreErrors) {
+            task.logError(`Error processing ${filename}: ${error.message}`);
+            resolve();
+          } else {
+            reject(error);
+          }
         }
       });
       parser.on("end", () => {
@@ -4717,7 +4724,16 @@ var importGtfsFiles = (db, task) => mapSeries2(
             try {
               insertLines(lines);
             } catch (error) {
-              reject(error);
+              if (task.ignoreErrors) {
+                task.logError(
+                  `Error inserting data for ${filename}: ${error.message}`
+                );
+                resolve();
+                return;
+              } else {
+                reject(error);
+                return;
+              }
             }
           }
           task.log(
@@ -4726,15 +4742,34 @@ var importGtfsFiles = (db, task) => mapSeries2(
           );
           resolve();
         } catch (error) {
+          if (task.ignoreErrors) {
+            task.logError(`Error finalizing ${filename}: ${error.message}`);
+            resolve();
+          } else {
+            reject(error);
+          }
+        }
+      });
+      parser.on("error", (error) => {
+        if (task.ignoreErrors) {
+          task.logError(`Parser error for ${filename}: ${error.message}`);
+          resolve();
+        } else {
           reject(error);
         }
       });
-      parser.on("error", reject);
       createReadStream(filepath).pipe(stripBomStream()).pipe(parser);
     } else if (model.filenameExtension === "geojson") {
       readFile2(filepath, "utf8").then((data) => {
         if (isValidJSON(data) === false) {
-          reject(new Error(`Invalid JSON in ${filename}`));
+          if (task.ignoreErrors) {
+            task.logError(`Invalid JSON in ${filename}`);
+            resolve();
+            return;
+          } else {
+            reject(new Error(`Invalid JSON in ${filename}`));
+            return;
+          }
         }
         totalLineCount += 1;
         const line = formatGtfsLine(
@@ -4742,30 +4777,54 @@ var importGtfsFiles = (db, task) => mapSeries2(
           model,
           totalLineCount
         );
-        insertLines([line]);
-        task.log(
-          `Importing - ${filename} - ${totalLineCount} lines imported\r`,
-          true
+        try {
+          insertLines([line]);
+          task.log(
+            `Importing - ${filename} - ${totalLineCount} lines imported\r`,
+            true
+          );
+          resolve();
+        } catch (error) {
+          if (task.ignoreErrors) {
+            task.logError(
+              `Error inserting data for ${filename}: ${error.message}`
+            );
+            resolve();
+          } else {
+            reject(error);
+          }
+        }
+      }).catch((error) => {
+        if (task.ignoreErrors) {
+          task.logError(`Error reading ${filename}: ${error.message}`);
+          resolve();
+        } else {
+          reject(error);
+        }
+      });
+    } else {
+      if (task.ignoreErrors) {
+        task.logError(
+          `Unsupported file type: ${model.filenameExtension} for ${filename}`
         );
         resolve();
-      }).catch(reject);
-    } else {
-      reject(
-        new Error(`Unsupported file type: ${model.filenameExtension}`)
-      );
+      } else {
+        reject(
+          new Error(`Unsupported file type: ${model.filenameExtension}`)
+        );
+      }
     }
   })
 );
 async function importGtfs(initialConfig) {
-  const timer = new Timer();
-  timer.start();
+  const startTime = process.hrtime.bigint();
   const config = setDefaultConfig(initialConfig);
   validateConfigForImport(config);
   try {
     const db = openDb(config);
     const agencyCount = config.agencies.length;
     log(config)(
-      `Starting GTFS import for ${pluralize2("file", agencyCount, true)} using SQLite database at ${config.sqlitePath}`
+      `Starting GTFS import for ${pluralize("file", "files", agencyCount)} using SQLite database at ${config.sqlitePath}`
     );
     createGtfsTables(db);
     await mapSeries2(config.agencies, async (agency2) => {
@@ -4809,10 +4868,10 @@ async function importGtfs(initialConfig) {
     });
     log(config)(`Creating DB indexes`);
     createGtfsIndexes(db);
-    const seconds = Math.round(timer.time() / 1e3);
-    timer.stop();
+    const endTime = process.hrtime.bigint();
+    const elapsedSeconds = Number(endTime - startTime) / 1e9;
     log(config)(
-      `Completed GTFS import for ${pluralize2("agency", agencyCount, true)} in ${seconds} seconds
+      `Completed GTFS import in ${elapsedSeconds.toFixed(1)} seconds
 `
     );
   } catch (error) {
@@ -4829,11 +4888,9 @@ async function importGtfs(initialConfig) {
 import path3 from "path";
 import { writeFile as writeFile2 } from "fs/promises";
 import { without, compact as compact2 } from "lodash-es";
-import pluralize3 from "pluralize";
 import { stringify } from "csv-stringify";
 import sqlString2 from "sqlstring-sqlite";
 import mapSeries3 from "promise-map-series";
-import untildify4 from "untildify";
 
 // src/lib/advancedQuery.ts
 import sqlString3 from "sqlstring-sqlite";