gtfs 4.17.2 → 4.17.4

package/dist/index.js

@@ -5,9 +5,9 @@ var __export = (target, all) => {
 };
 
 // src/lib/import-gtfs.ts
-import path from "node:path";
-import { createReadStream, existsSync, lstatSync } from "node:fs";
-import { cp, readdir, rename, readFile as readFile2, rm as rm2, writeFile } from "node:fs/promises";
+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";
@@ -29,12 +29,14 @@ __export(models_exports, {
   calendarDates: () => calendarDates,
   deadheadTimes: () => deadheadTimes,
   deadheads: () => deadheads,
+  devices: () => devices,
   directions: () => directions,
   fareAttributes: () => fareAttributes,
   fareLegRules: () => fareLegRules,
   fareMedia: () => fareMedia,
   fareProducts: () => fareProducts,
   fareRules: () => fareRules,
+  fareTransactions: () => fareTransactions,
   fareTransferRules: () => fareTransferRules,
   feedInfo: () => feedInfo,
   frequencies: () => frequencies,
@@ -43,7 +45,9 @@ __export(models_exports, {
   locationGroups: () => locationGroups,
   locations: () => locations,
   networks: () => networks,
+  operators: () => operators,
   opsLocations: () => opsLocations,
+  passengerEvents: () => passengerEvents,
   pathways: () => pathways,
   rideFeedInfo: () => rideFeedInfo,
   riderCategories: () => riderCategories,
@@ -57,10 +61,12 @@ __export(models_exports, {
   serviceAlertInformedEntities: () => serviceAlertInformedEntities,
   serviceAlerts: () => serviceAlerts,
   shapes: () => shapes,
+  stationActivities: () => stationActivities,
   stopAreas: () => stopAreas,
   stopAttributes: () => stopAttributes,
   stopTimeUpdates: () => stopTimeUpdates,
   stopTimes: () => stopTimes,
+  stopVisits: () => stopVisits,
   stops: () => stops,
   timeframes: () => timeframes,
   timetableNotes: () => timetableNotes,
@@ -68,13 +74,18 @@ __export(models_exports, {
   timetablePages: () => timetablePages,
   timetableStopOrder: () => timetableStopOrder,
   timetables: () => timetables,
+  trainCars: () => trainCars,
   transfers: () => transfers,
   translations: () => translations,
   tripCapacity: () => tripCapacity,
   tripUpdates: () => tripUpdates,
   trips: () => trips,
   tripsDatedVehicleJourney: () => tripsDatedVehicleJourney,
-  vehiclePositions: () => vehiclePositions
+  tripsPerformed: () => tripsPerformed,
+  vehicleLocations: () => vehicleLocations,
+  vehiclePositions: () => vehiclePositions,
+  vehicleTrainCars: () => vehicleTrainCars,
+  vehicles: () => vehicles
 });
 
 // src/models/gtfs/agency.ts
@@ -548,6 +559,7 @@ var fareProducts = {
     {
       name: "rider_category_id",
       type: "text",
+      primary: true,
       prefix: true
     },
     {
@@ -3122,143 +3134,978 @@ var runsPieces = {
   ]
 };
 
-// src/lib/db.ts
-import fs from "fs";
-import Database from "better-sqlite3";
-import untildify from "untildify";
-var dbs = {};
-function setupDb(sqlitePath) {
-  const db = new Database(untildify(sqlitePath));
-  db.pragma("journal_mode = OFF");
-  db.pragma("synchronous = OFF");
-  db.pragma("temp_store = MEMORY");
-  dbs[sqlitePath] = db;
-  return db;
-}
-function openDb(config = null) {
-  if (config) {
-    const { sqlitePath = ":memory:", db } = config;
-    if (db) {
-      return db;
-    }
-    if (dbs[sqlitePath]) {
-      return dbs[sqlitePath];
-    }
-    return setupDb(sqlitePath);
-  }
-  if (Object.keys(dbs).length === 0) {
-    return setupDb(":memory:");
-  }
-  if (Object.keys(dbs).length === 1) {
-    const filename = Object.keys(dbs)[0];
-    return dbs[filename];
-  }
-  if (Object.keys(dbs).length > 1) {
-    throw new Error(
-      "Multiple databases open, please specify which one to use."
-    );
-  }
-  throw new Error("Unable to find database connection.");
-}
-function closeDb(db = null) {
-  if (Object.keys(dbs).length === 0) {
-    throw new Error(
-      "No database connection. Call `openDb(config)` before using any methods."
-    );
-  }
-  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`."
-      );
-    }
-    db = dbs[Object.keys(dbs)[0]];
-  }
-  db.close();
-  delete dbs[db.name];
-}
-function deleteDb(db = null) {
-  if (Object.keys(dbs).length === 0) {
-    throw new Error(
-      "No database connection. Call `openDb(config)` before using any methods."
-    );
-  }
-  if (!db) {
-    if (Object.keys(dbs).length > 1) {
-      throw new Error(
-        "Multiple database connections. Pass the db you want to delete as a parameter to `deleteDb`."
-      );
+// src/models/tides/devices.ts
+var devices = {
+  filenameBase: "devices",
+  filenameExtension: "txt",
+  nonstandard: true,
+  extension: "tides",
+  schema: [
+    {
+      name: "device_id",
+      type: "text",
+      required: true,
+      primary: true
+    },
+    {
+      name: "stop_id",
+      type: "text"
+    },
+    {
+      name: "vehicle_id",
+      type: "text"
+    },
+    {
+      name: "train_car_id",
+      type: "text"
+    },
+    {
+      name: "device_type",
+      type: "text"
+    },
+    {
+      name: "device_vendor",
+      type: "text"
+    },
+    {
+      name: "device_model",
+      type: "text"
+    },
+    {
+      name: "device_location",
+      type: "text"
     }
-    db = dbs[Object.keys(dbs)[0]];
-  }
-  db.close();
-  fs.unlinkSync(db.name);
-  delete dbs[db.name];
-}
-
-// src/lib/file-utils.ts
-import { mkdir, readFile, rm } from "node:fs/promises";
-import { omit, snakeCase } from "lodash-es";
-import sanitize from "sanitize-filename";
-import untildify2 from "untildify";
-import StreamZip from "node-stream-zip";
+  ]
+};
 
-// src/lib/log-utils.ts
-import { clearLine, cursorTo } from "node:readline";
-import { noop } from "lodash-es";
-import * as colors from "yoctocolors";
-function log(config) {
-  if (config.verbose === false) {
-    return noop;
-  }
-  if (config.logFunction) {
-    return config.logFunction;
-  }
-  return (text, overwrite = false) => {
-    if (overwrite && process.stdout.isTTY) {
-      clearLine(process.stdout, 0);
-      cursorTo(process.stdout, 0);
-    } else {
-      process.stdout.write("\n");
+// src/models/tides/fare-transactions.ts
+var fareTransactions = {
+  filenameBase: "fare_transactions",
+  filenameExtension: "txt",
+  nonstandard: true,
+  extension: "tides",
+  schema: [
+    {
+      name: "transaction_id",
+      type: "text",
+      required: true,
+      index: true
+    },
+    {
+      name: "service_date",
+      type: "date",
+      required: true
+    },
+    {
+      name: "event_timestamp",
+      type: "text",
+      required: true
+    },
+    {
+      name: "location_ping_id",
+      type: "text"
+    },
+    {
+      name: "amount",
+      type: "real",
+      required: true
+    },
+    {
+      name: "currency_type",
+      type: "text"
+    },
+    {
+      name: "fare_action",
+      type: "text",
+      required: true
+    },
+    {
+      name: "trip_id_performed",
+      type: "text"
+    },
+    {
+      name: "trip_id_scheduled",
+      type: "text"
+    },
+    {
+      name: "pattern_id",
+      type: "text"
+    },
+    {
+      name: "trip_stop_sequence",
+      type: "integer",
+      min: 1
+    },
+    {
+      name: "scheduled_stop_sequence",
+      type: "integer",
+      min: 0
+    },
+    {
+      name: "vehicle_id",
+      type: "text"
+    },
+    {
+      name: "device_id",
+      type: "text"
+    },
+    {
+      name: "fare_id",
+      type: "text"
+    },
+    {
+      name: "stop_id",
+      type: "text"
+    },
+    {
+      name: "num_riders",
+      type: "integer",
+      min: 0
+    },
+    {
+      name: "fare_media_id",
+      type: "text"
+    },
+    {
+      name: "rider_category",
+      type: "text"
+    },
+    {
+      name: "fare_product",
+      type: "text"
+    },
+    {
+      name: "fare_period",
+      type: "text"
+    },
+    {
+      name: "fare_capped",
+      type: "text",
+      required: true
+    },
+    {
+      name: "token_id",
+      type: "text"
+    },
+    {
+      name: "balance",
+      type: "real"
     }
-    process.stdout.write(text);
-  };
-}
-function logWarning(config) {
-  if (config.logFunction) {
-    return config.logFunction;
-  }
-  return (text) => {
-    process.stdout.write(`
-${formatWarning(text)}
-`);
-  };
-}
-function logError(config) {
-  if (config.logFunction) {
-    return config.logFunction;
-  }
-  return (text) => {
-    process.stdout.write(`
-${formatError(text)}
-`);
-  };
-}
-function formatWarning(text) {
-  return colors.yellow(`${colors.underline("Warning")}: ${text}`);
-}
-function formatError(error) {
-  const messageText = error instanceof Error ? error.message : error;
-  const cleanMessage = messageText.replace(/^Error:\s*/i, "");
-  return colors.red(`${colors.underline("Error")}: ${cleanMessage}`);
-}
+  ]
+};
 
-// src/lib/file-utils.ts
-async function prepDirectory(exportPath) {
-  await rm(exportPath, { recursive: true, force: true });
-  await mkdir(exportPath, { recursive: true });
-}
-async function unzip(zipfilePath, exportPath) {
+// src/models/tides/operators.ts
+var operators = {
+  filenameBase: "operators",
+  filenameExtension: "txt",
+  nonstandard: true,
+  extension: "tides",
+  schema: [
+    {
+      name: "operator_id",
+      type: "text",
+      required: true,
+      primary: true
+    }
+  ]
+};
+
+// src/models/tides/passenger-events.ts
+var passengerEvents = {
+  filenameBase: "passenger_events",
+  filenameExtension: "txt",
+  nonstandard: true,
+  extension: "tides",
+  schema: [
+    {
+      name: "passenger_event_id",
+      type: "text",
+      required: true,
+      index: true
+    },
+    {
+      name: "service_date",
+      type: "date",
+      required: true
+    },
+    {
+      name: "event_timestamp",
+      type: "text",
+      required: true
+    },
+    {
+      name: "location_ping_id",
+      type: "text"
+    },
+    {
+      name: "trip_id_performed",
+      type: "text"
+    },
+    {
+      name: "trip_id_scheduled",
+      type: "text"
+    },
+    {
+      name: "trip_stop_sequence",
+      type: "integer",
+      min: 1
+    },
+    {
+      name: "scheduled_stop_sequence",
+      type: "integer",
+      min: 0
+    },
+    {
+      name: "event_type",
+      type: "text",
+      required: true
+    },
+    {
+      name: "vehicle_id",
+      type: "text",
+      required: true
+    },
+    {
+      name: "device_id",
+      type: "text"
+    },
+    {
+      name: "train_car_id",
+      type: "text"
+    },
+    {
+      name: "stop_id",
+      type: "text"
+    },
+    {
+      name: "pattern_id",
+      type: "text"
+    },
+    {
+      name: "event_count",
+      type: "integer",
+      min: 0
+    }
+  ]
+};
+
+// src/models/tides/station-activities.ts
+var stationActivities = {
+  filenameBase: "station_activities",
+  filenameExtension: "txt",
+  nonstandard: true,
+  extension: "tides",
+  schema: [
+    {
+      name: "service_date",
+      type: "date",
+      required: true,
+      primary: true
+    },
+    {
+      name: "stop_id",
+      type: "text",
+      required: true,
+      primary: true
+    },
+    {
+      name: "time_period_start",
+      type: "text",
+      required: true,
+      primary: true
+    },
+    {
+      name: "time_period_end",
+      type: "text",
+      required: true,
+      primary: true
+    },
+    {
+      name: "time_period_category",
+      type: "text"
+    },
+    {
+      name: "total_entries",
+      type: "integer",
+      min: 0
+    },
+    {
+      name: "total_exits",
+      type: "integer",
+      min: 0
+    },
+    {
+      name: "number_of_transactions",
+      type: "integer",
+      min: 0
+    },
+    {
+      name: "bike_entries",
+      type: "integer",
+      min: 0
+    },
+    {
+      name: "bike_exits",
+      type: "integer",
+      min: 0
+    },
+    {
+      name: "ramp_entries",
+      type: "integer",
+      min: 0
+    },
+    {
+      name: "ramp_exits",
+      type: "integer",
+      min: 0
+    }
+  ]
+};
+
+// src/models/tides/stop-visits.ts
+var stopVisits = {
+  filenameBase: "stop_visits",
+  filenameExtension: "txt",
+  nonstandard: true,
+  extension: "tides",
+  schema: [
+    {
+      name: "service_date",
+      type: "date",
+      required: true,
+      primary: true
+    },
+    {
+      name: "trip_id_performed",
+      type: "text",
+      required: true,
+      primary: true
+    },
+    {
+      name: "trip_stop_sequence",
+      type: "integer",
+      min: 1,
+      required: true,
+      primary: true
+    },
+    {
+      name: "scheduled_stop_sequence",
+      type: "integer",
+      min: 0
+    },
+    {
+      name: "pattern_id",
+      type: "text"
+    },
+    {
+      name: "vehicle_id",
+      type: "text"
+    },
+    {
+      name: "dwell",
+      type: "integer",
+      min: 0
+    },
+    {
+      name: "stop_id",
+      type: "text"
+    },
+    {
+      name: "timepoint",
+      type: "text"
+    },
+    {
+      name: "schedule_arrival_time",
+      type: "text"
+    },
+    {
+      name: "schedule_departure_time",
+      type: "text"
+    },
+    {
+      name: "actual_arrival_time",
+      type: "text"
+    },
+    {
+      name: "actual_departure_time",
+      type: "text"
+    },
+    {
+      name: "distance",
+      type: "integer",
+      min: 0
+    },
+    {
+      name: "boarding_1",
+      type: "integer",
+      min: 0
+    },
+    {
+      name: "alighting_1",
+      type: "integer",
+      min: 0
+    },
+    {
+      name: "boarding_2",
+      type: "integer",
+      min: 0
+    },
+    {
+      name: "alighting_2",
+      type: "integer",
+      min: 0
+    },
+    {
+      name: "departure_load",
+      type: "integer",
+      min: 0
+    },
+    {
+      name: "door_open",
+      type: "text"
+    },
+    {
+      name: "door_close",
+      type: "text"
+    },
+    {
+      name: "door_status",
+      type: "text"
+    },
+    {
+      name: "ramp_deployed_time",
+      type: "text"
+    },
+    {
+      name: "ramp_failure",
+      type: "text"
+    },
+    {
+      name: "kneel_deployed_time",
+      type: "integer",
+      min: 0
+    },
+    {
+      name: "lift_deployed_time",
+      type: "integer",
+      min: 0
+    },
+    {
+      name: "bike_rack_deployed",
+      type: "text"
+    },
+    {
+      name: "bike_load",
+      type: "integer",
+      min: 0
+    },
+    {
+      name: "revenue",
+      type: "real"
+    },
+    {
+      name: "number_of_transactions",
+      type: "integer",
+      min: 0
+    },
+    {
+      name: "schedule_relationship",
+      type: "text"
+    }
+  ]
+};
+
+// src/models/tides/train-cars.ts
+var trainCars = {
+  filenameBase: "train_cars",
+  filenameExtension: "txt",
+  nonstandard: true,
+  extension: "tides",
+  schema: [
+    {
+      name: "train_car_id",
+      type: "text",
+      required: true,
+      primary: true
+    },
+    {
+      name: "model_name",
+      type: "text"
+    },
+    {
+      name: "facility_name",
+      type: "text"
+    },
+    {
+      name: "capacity_seated",
+      type: "integer",
+      min: 0
+    },
+    {
+      name: "capacity_wheelchair",
+      type: "integer",
+      min: 0
+    },
+    {
+      name: "capacity_bike",
+      type: "integer",
+      min: 0
+    },
+    {
+      name: "bike_rack",
+      type: "text"
+    },
+    {
+      name: "capacity_standing",
+      type: "integer",
+      min: 0
+    },
+    {
+      name: "train_car_type",
+      type: "text"
+    }
+  ]
+};
+
+// src/models/tides/trips-performed.ts
+var tripsPerformed = {
+  filenameBase: "trips_performed",
+  filenameExtension: "txt",
+  nonstandard: true,
+  extension: "tides",
+  schema: [
+    {
+      name: "service_date",
+      type: "date",
+      required: true,
+      primary: true
+    },
+    {
+      name: "trip_id_performed",
+      type: "text",
+      required: true,
+      primary: true
+    },
+    {
+      name: "vehicle_id",
+      type: "text",
+      required: true
+    },
+    {
+      name: "trip_id_scheduled",
+      type: "text"
+    },
+    {
+      name: "route_id",
+      type: "text"
+    },
+    {
+      name: "route_type",
+      type: "text"
+    },
+    {
+      name: "ntd_mode",
+      type: "text"
+    },
+    {
+      name: "route_type_agency",
+      type: "text"
+    },
+    {
+      name: "shape_id",
+      type: "text"
+    },
+    {
+      name: "pattern_id",
+      type: "text"
+    },
+    {
+      name: "direction_id",
+      type: "integer",
+      min: 0,
+      max: 1
+    },
+    {
+      name: "operator_id",
+      type: "text"
+    },
+    {
+      name: "block_id",
+      type: "text"
+    },
+    {
+      name: "trip_start_stop_id",
+      type: "text"
+    },
+    {
+      name: "trip_end_stop_id",
+      type: "text"
+    },
+    {
+      name: "schedule_trip_start",
+      type: "text"
+    },
+    {
+      name: "schedule_trip_end",
+      type: "text"
+    },
+    {
+      name: "actual_trip_start",
+      type: "text"
+    },
+    {
+      name: "actual_trip_end",
+      type: "text"
+    },
+    {
+      name: "trip_type",
+      type: "text"
+    },
+    {
+      name: "schedule_relationship",
+      type: "text"
+    }
+  ]
+};
+
+// src/models/tides/vehicle-train-cars.ts
+var vehicleTrainCars = {
+  filenameBase: "vehicle_train_cars",
+  filenameExtension: "txt",
+  nonstandard: true,
+  extension: "tides",
+  schema: [
+    {
+      name: "vehicle_id",
+      type: "text",
+      required: true,
+      primary: true
+    },
+    {
+      name: "train_car_id",
+      type: "text",
+      required: true,
+      primary: true
+    },
+    {
+      name: "train_car_order",
+      type: "integer",
+      min: 0
+    },
+    {
+      name: "operator_id",
+      type: "text"
+    }
+  ]
+};
+
+// src/models/tides/vehicle-locations.ts
+var vehicleLocations = {
+  filenameBase: "vehicle_locations",
+  filenameExtension: "txt",
+  nonstandard: true,
+  extension: "tides",
+  schema: [
+    {
+      name: "location_ping_id",
+      type: "text",
+      required: true,
+      primary: true
+    },
+    {
+      name: "service_date",
+      type: "date"
+    },
+    {
+      name: "event_timestamp",
+      type: "text",
+      required: true
+    },
+    {
+      name: "trip_id_performed",
+      type: "text"
+    },
+    {
+      name: "trip_id_scheduled",
+      type: "text"
+    },
+    {
+      name: "trip_stop_sequence",
+      type: "integer",
+      min: 1
+    },
+    {
+      name: "scheduled_stop_sequence",
+      type: "integer",
+      min: 0
+    },
+    {
+      name: "vehicle_id",
+      type: "text",
+      required: true
+    },
+    {
+      name: "device_id",
+      type: "text"
+    },
+    {
+      name: "pattern_id",
+      type: "text"
+    },
+    {
+      name: "stop_id",
+      type: "text"
+    },
+    {
+      name: "current_status",
+      type: "text"
+    },
+    {
+      name: "latitude",
+      type: "real",
+      min: -90,
+      max: 90
+    },
+    {
+      name: "longitude",
+      type: "real",
+      min: -180,
+      max: 180
+    },
+    {
+      name: "gps_quality",
+      type: "text"
+    },
+    {
+      name: "heading",
+      type: "real",
+      min: 0,
+      max: 360
+    },
+    {
+      name: "speed",
+      type: "real",
+      min: 0
+    },
+    {
+      name: "odometer",
+      type: "real",
+      min: 0
+    },
+    {
+      name: "schedule_deviation",
+      type: "integer"
+    },
+    {
+      name: "headway_deviation",
+      type: "integer"
+    },
+    {
+      name: "trip_type",
+      type: "text"
+    },
+    {
+      name: "schedule_relationship",
+      type: "text"
+    }
+  ]
+};
+
+// src/models/tides/vehicles.ts
+var vehicles = {
+  filenameBase: "vehicles",
+  filenameExtension: "txt",
+  nonstandard: true,
+  extension: "tides",
+  schema: [
+    {
+      name: "vehicle_id",
+      type: "text",
+      required: true,
+      primary: true
+    },
+    {
+      name: "vehicle_start",
+      type: "text"
+    },
+    {
+      name: "vehicle_end",
+      type: "text"
+    },
+    {
+      name: "model_name",
+      type: "text"
+    },
+    {
+      name: "facility_name",
+      type: "text"
+    },
+    {
+      name: "capacity_seated",
+      type: "integer",
+      min: 0
+    },
+    {
+      name: "capacity_wheelchair",
+      type: "integer",
+      min: 0
+    },
+    {
+      name: "capacity_bike",
+      type: "integer",
+      min: 0
+    },
+    {
+      name: "bike_rack",
+      type: "text"
+    },
+    {
+      name: "capacity_standing",
+      type: "integer",
+      min: 0
+    }
+  ]
+};
+
+// src/lib/db.ts
+import fs from "fs";
+import Database from "better-sqlite3";
+import untildify from "untildify";
+var dbs = {};
+function setupDb(sqlitePath) {
+  const db = new Database(untildify(sqlitePath));
+  db.pragma("journal_mode = OFF");
+  db.pragma("synchronous = OFF");
+  db.pragma("temp_store = MEMORY");
+  dbs[sqlitePath] = db;
+  return db;
+}
+function openDb(config = null) {
+  if (config) {
+    const { sqlitePath = ":memory:", db } = config;
+    if (db) {
+      return db;
+    }
+    if (dbs[sqlitePath]) {
+      return dbs[sqlitePath];
+    }
+    return setupDb(sqlitePath);
+  }
+  if (Object.keys(dbs).length === 0) {
+    return setupDb(":memory:");
+  }
+  if (Object.keys(dbs).length === 1) {
+    const filename = Object.keys(dbs)[0];
+    return dbs[filename];
+  }
+  if (Object.keys(dbs).length > 1) {
+    throw new Error(
+      "Multiple databases open, please specify which one to use."
+    );
+  }
+  throw new Error("Unable to find database connection.");
+}
+function closeDb(db = null) {
+  if (Object.keys(dbs).length === 0) {
+    throw new Error(
+      "No database connection. Call `openDb(config)` before using any methods."
+    );
+  }
+  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`."
+      );
+    }
+    db = dbs[Object.keys(dbs)[0]];
+  }
+  db.close();
+  delete dbs[db.name];
+}
+function deleteDb(db = null) {
+  if (Object.keys(dbs).length === 0) {
+    throw new Error(
+      "No database connection. Call `openDb(config)` before using any methods."
+    );
+  }
+  if (!db) {
+    if (Object.keys(dbs).length > 1) {
+      throw new Error(
+        "Multiple database connections. Pass the db you want to delete as a parameter to `deleteDb`."
+      );
+    }
+    db = dbs[Object.keys(dbs)[0]];
+  }
+  db.close();
+  fs.unlinkSync(db.name);
+  delete dbs[db.name];
+}
+
+// src/lib/file-utils.ts
+import path from "path";
+import { existsSync } from "fs";
+import { mkdir, readFile, rm } from "fs/promises";
+import { omit, snakeCase } from "lodash-es";
+import sanitize from "sanitize-filename";
+import untildify2 from "untildify";
+import StreamZip from "node-stream-zip";
+
+// src/lib/log-utils.ts
+import { clearLine, cursorTo } from "readline";
+import { noop } from "lodash-es";
+import * as colors from "yoctocolors";
+function log(config) {
+  if (config.verbose === false) {
+    return noop;
+  }
+  if (config.logFunction) {
+    return config.logFunction;
+  }
+  return (text, overwrite = false) => {
+    if (overwrite && process.stdout.isTTY) {
+      clearLine(process.stdout, 0);
+      cursorTo(process.stdout, 0);
+    } else {
+      process.stdout.write("\n");
+    }
+    process.stdout.write(text);
+  };
+}
+function logWarning(config) {
+  if (config.logFunction) {
+    return config.logFunction;
+  }
+  return (text) => {
+    process.stdout.write(`
+${formatWarning(text)}
+`);
+  };
+}
+function logError(config) {
+  if (config.logFunction) {
+    return config.logFunction;
+  }
+  return (text) => {
+    process.stdout.write(`
+${formatError(text)}
+`);
+  };
+}
+function formatWarning(text) {
+  return colors.yellow(`${colors.underline("Warning")}: ${text}`);
+}
+function formatError(error) {
+  const messageText = error instanceof Error ? error.message : error;
+  const cleanMessage = messageText.replace(/^Error:\s*/i, "");
+  return colors.red(`${colors.underline("Error")}: ${cleanMessage}`);
+}
+
+// src/lib/file-utils.ts
+async function prepDirectory(exportPath) {
+  await rm(exportPath, { recursive: true, force: true });
+  await mkdir(exportPath, { recursive: true });
+}
+async function unzip(zipfilePath, exportPath) {
   try {
     const zip = new StreamZip.async({ file: zipfilePath });
     await zip.extract(null, exportPath);
@@ -3850,18 +4697,6 @@ async function updateGtfsRealtime(initialConfig) {
 }
 
 // src/lib/import-gtfs.ts
-var timeCache = {};
-var formatAndCacheTime = (value) => {
-  const cached = timeCache[value];
-  if (cached !== void 0) {
-    return cached;
-  }
-  const timeAsSecondsFromMidnight = calculateSecondsFromMidnight(value);
-  const timeAsString = padLeadingZeros(value);
-  const computed = [timeAsSecondsFromMidnight, timeAsString];
-  timeCache[value] = computed;
-  return computed;
-};
 var getTextFiles = async (folderPath) => {
   const files = await readdir(folderPath);
   return files.filter((filename) => filename.slice(-3) === "txt");
@@ -3892,13 +4727,13 @@ var extractGtfsFiles = async (task) => {
   }
   const gtfsPath = untildify3(task.path);
   task.log(`Importing GTFS from ${task.path}\r`);
-  if (path.extname(gtfsPath) === ".zip") {
+  if (path2.extname(gtfsPath) === ".zip") {
     try {
       await unzip(gtfsPath, task.downloadDir);
       const textFiles = await getTextFiles(task.downloadDir);
       if (textFiles.length === 0) {
         const files = await readdir(task.downloadDir);
-        const folders = files.filter((filename) => !["__MACOSX"].includes(filename)).map((filename) => path.join(task.downloadDir, filename)).filter((source) => lstatSync(source).isDirectory());
+        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.`
@@ -3918,8 +4753,8 @@ var extractGtfsFiles = async (task) => {
         await Promise.all(
           directoryTextFiles.map(
             async (fileName) => rename(
-              path.join(subfolderName, fileName),
-              path.join(task.downloadDir, fileName)
+              path2.join(subfolderName, fileName),
+              path2.join(task.downloadDir, fileName)
             )
           )
         );
@@ -3973,7 +4808,16 @@ var createGtfsTables = (db) => {
       );
       if (column.type === "time") {
         sqlColumnCreateStatements.push(
-          `${getTimestampColumnName(column.name)} INTEGER`
+          `${getTimestampColumnName(column.name)} INTEGER GENERATED ALWAYS AS (
+            CASE 
+              WHEN ${column.name} IS NULL OR ${column.name} = '' THEN NULL 
+              ELSE CAST(
+                substr(${column.name}, 1, instr(${column.name}, ':') - 1) * 3600 + 
+                substr(${column.name}, instr(${column.name}, ':') + 1, 2) * 60 + 
+                substr(${column.name}, -2) AS INTEGER
+              )
+            END
+          ) STORED`
         );
       }
     }
@@ -4018,9 +4862,6 @@ var formatGtfsLine = (line, model, totalLineCount) => {
     let value = line[name];
     if (value === "" || value === void 0 || value === null) {
       formattedLine[name] = null;
-      if (type === "time") {
-        formattedLine[getTimestampColumnName(name)] = null;
-      }
       if (required) {
         throw new Error(
           `Missing required value in ${filenameBase}.${filenameExtension} for ${name} on line ${lineNumber}.`
@@ -4036,9 +4877,7 @@ var formatGtfsLine = (line, model, totalLineCount) => {
         );
       }
     } else if (type === "time") {
-      const [timeAsSecondsFromMidnight, timeAsString] = formatAndCacheTime(value);
-      value = timeAsString;
-      formattedLine[getTimestampColumnName(name)] = timeAsSecondsFromMidnight ?? null;
+      value = padLeadingZeros(value);
     }
     if (type === "json") {
       value = JSON.stringify(value);
@@ -4062,8 +4901,8 @@ var importGtfsFiles = (db, task) => mapSeries2(
       resolve();
       return;
     }
-    const filepath = path.join(task.downloadDir, `${filename}`);
-    if (!existsSync(filepath)) {
+    const filepath = path2.join(task.downloadDir, `${filename}`);
+    if (!existsSync2(filepath)) {
       if (!model.nonstandard) {
         task.log(`Importing - ${filename} - No file found\r`);
       }
@@ -4071,19 +4910,7 @@ var importGtfsFiles = (db, task) => mapSeries2(
       return;
     }
     task.log(`Importing - ${filename}\r`);
-    const columns = model.schema.flatMap((column) => {
-      if (column.type === "time") {
-        return [
-          column,
-          {
-            name: getTimestampColumnName(column.name),
-            type: "integer",
-            index: true
-          }
-        ];
-      }
-      return column;
-    });
+    const columns = model.schema;
     const prefixedColumns = new Set(
       columns.filter((column) => column.prefix).map((column) => column.name)
     );
@@ -4268,8 +5095,8 @@ async function importGtfs(initialConfig) {
 }
 
 // src/lib/export.ts
-import path2 from "node:path";
-import { writeFile as writeFile2 } from "node:fs/promises";
+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";
@@ -4312,7 +5139,7 @@ var exportGtfs = async (initialConfig) => {
     )} using SQLite database at ${config.sqlitePath}`
   );
   const folderName = generateFolderName(agencies[0].agency_name);
-  const defaultExportPath = path2.join(process.cwd(), "gtfs-export", folderName);
+  const defaultExportPath = path3.join(process.cwd(), "gtfs-export", folderName);
   const exportPath = untildify4(config.exportPath || defaultExportPath);
   await prepDirectory(exportPath);
   const modelsToExport = Object.values(models_exports).filter(
@@ -4321,7 +5148,7 @@ var exportGtfs = async (initialConfig) => {
   const exportedFiles = await mapSeries3(
     modelsToExport,
     async (model) => {
-      const filePath = path2.join(
+      const filePath = path3.join(
         exportPath,
         `${model.filenameBase}.${model.filenameExtension}`
       );