@golemio/pid 6.4.0 → 6.4.1-dev.3054859807

package/dist/integration-engine/jis/repositories/JISDelayedSegmentsRepository.js

@@ -0,0 +1,73 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { PG_SCHEMA } from "#sch/const";
+import { JISDelayedSegmentsModel } from "#sch/jis/models/JISDelayedSegmentsModel";
+import { AbstractValidatableRepository } from "@golemio/core/dist/helpers/data-access/postgres/repositories/AbstractValidatableRepository.js";
+import { CoreToken } from "@golemio/core/dist/helpers/ioc/CoreToken.js";
+import GolemioErrorsCore from "@golemio/core/dist/shared/golemio-errors.js";
+const { GeneralError } = GolemioErrorsCore;
+import GolemioValidatorCore from "@golemio/core/dist/shared/golemio-validator.js";
+const { JSONSchemaValidator } = GolemioValidatorCore;
+import SequelizeCore from "@golemio/core/dist/shared/sequelize.js";
+const { Op } = SequelizeCore;
+import { inject, injectable } from "@golemio/core/dist/shared/tsyringe.js";
+let JISDelayedSegmentsRepository = class JISDelayedSegmentsRepository extends AbstractValidatableRepository {
+    constructor(connector, logger) {
+        super(connector, logger);
+        this.schema = PG_SCHEMA;
+        this.tableName = JISDelayedSegmentsModel.tableName;
+        this.validator = new JSONSchemaValidator("JISDelayedSegmentsRepository", JISDelayedSegmentsModel.jsonSchema);
+        this.sequelizeModel = connector
+            .getConnection()
+            .define(this.tableName, JISDelayedSegmentsModel.attributeModel, { schema: this.schema });
+    }
+    /**
+     * Replaces all delayed segments with the given ones. `updated_at` of every given segment is set to `detectedAt`,
+     * `created_at` keeps the time the segment was first detected. Segments absent from the given data are deleted.
+     */
+    async refreshData(segments, detectedAt) {
+        await this.validator.Validate(segments);
+        const transaction = await this.connector.getConnection().transaction();
+        try {
+            const rows = segments.map((segment) => ({ ...segment, created_at: detectedAt, updated_at: detectedAt }));
+            await this.sequelizeModel.bulkCreate(rows, {
+                updateOnDuplicate: this.getUpdateAttributes(),
+                transaction,
+            });
+            await this.sequelizeModel.destroy({
+                where: { updated_at: { [Op.lt]: detectedAt } },
+                transaction,
+            });
+            await transaction.commit();
+        }
+        catch (error) {
+            await transaction.rollback();
+            throw new GeneralError("Error while refreshing delayed segments", this.constructor.name, error);
+        }
+    }
+    /**
+     * All attributes except created_at, which keeps the time the segment was first detected
+     */
+    getUpdateAttributes() {
+        const attributes = Object.keys(JISDelayedSegmentsModel.attributeModel);
+        return attributes.filter((attribute) => attribute !== "created_at");
+    }
+};
+JISDelayedSegmentsRepository = __decorate([
+    injectable(),
+    __param(0, inject(CoreToken.PostgresConnector)),
+    __param(1, inject(CoreToken.Logger)),
+    __metadata("design:paramtypes", [Object, Object])
+], JISDelayedSegmentsRepository);
+export { JISDelayedSegmentsRepository };
+//# sourceMappingURL=JISDelayedSegmentsRepository.js.map

package/dist/integration-engine/jis/repositories/JISDelayedSegmentsRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"JISDelayedSegmentsRepository.js","sourceRoot":"","sources":["../../../../src/integration-engine/jis/repositories/JISDelayedSegmentsRepository.ts"],"names":[],"mappings":"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"}

package/dist/integration-engine/jis/repositories/helpers/JISDelayedSegmentEnrichmentQuery.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Enriches delayed segments given by the ASW ids of their endpoints with their stops, affected routes and info panel
+ * stops. All segments of a refresh are enriched by one query, so that planning and lookups shared by the segments
+ * are done only once.
+ *
+ * Replacements: segments (JSON array of objects with segment_index, from_node_id, from_stop_id, to_node_id and
+ * to_stop_id), windowStart, windowEnd (departures taken into account) and maxInfoPanelDistanceStops (max distance
+ * of an info panel stop from the segment).
+ *
+ * Returns one row per segment, ordered by segment_index. Stops are matched by ASW id rather than by GTFS stop_id,
+ * since one physical stop can have several GTFS stop ids (zone and temporary variants).
+ */
+export declare const JIS_DELAYED_SEGMENT_ENRICHMENT_QUERY = "\nWITH\nsegments AS MATERIALIZED (\n    SELECT *\n    FROM jsonb_to_recordset(CAST(:segments AS jsonb))\n        AS segment(segment_index int, from_node_id int, from_stop_id int, to_node_id int, to_stop_id int)\n),\n-- GTFS stop ids of the segment endpoints, all variants of their ASW ids\nendpoint_stops AS MATERIALIZED (\n    SELECT seg.segment_index, TRUE AS is_from, s.stop_id\n    FROM segments seg\n    JOIN pid.ropidgtfs_stops s ON s.asw_node_id = seg.from_node_id AND s.asw_stop_id = seg.from_stop_id\n    UNION ALL\n    SELECT seg.segment_index, FALSE AS is_from, s.stop_id\n    FROM segments seg\n    JOIN pid.ropidgtfs_stops s ON s.asw_node_id = seg.to_node_id AND s.asw_stop_id = seg.to_stop_id\n),\n-- Regular trips in the time window running the whole segment, they define which stops lie on the segment\nsegment_trips AS MATERIALIZED (\n    SELECT DISTINCT\n        from_stop.segment_index,\n        d_from.trip_id,\n        d_from.date,\n        d_from.stop_sequence AS from_sequence,\n        d_to.stop_sequence AS to_sequence\n    FROM endpoint_stops from_stop\n    JOIN pid.ropidgtfs_precomputed_departures d_from\n        ON d_from.stop_id = from_stop.stop_id\n        AND d_from.departure_datetime BETWEEN :windowStart AND :windowEnd\n    JOIN pid.ropidgtfs_precomputed_departures d_to\n        ON d_to.date = d_from.date\n        AND d_to.trip_id = d_from.trip_id\n        AND d_to.stop_sequence > d_from.stop_sequence\n    JOIN endpoint_stops to_stop\n        ON to_stop.segment_index = from_stop.segment_index\n        AND NOT to_stop.is_from\n        AND to_stop.stop_id = d_to.stop_id\n    JOIN pid.ropidgtfs_trips t ON t.trip_id = d_from.trip_id AND t.exceptional = 0\n    WHERE from_stop.is_from\n),\n-- Stops between the endpoints along each segment trip, with their position relative to the trip's run of the segment\n-- (0 at the start, 1 at the end), so that trips skipping stops agree on the positions of the stops they share\nsegment_trip_stops AS MATERIALIZED (\n    SELECT\n        st.segment_index,\n        st.trip_id,\n        st.date,\n        d.stop_sequence,\n        s.stop_id,\n        s.stop_name,\n        s.asw_node_id,\n        s.asw_stop_id,\n        CAST(d.stop_sequence - st.from_sequence AS numeric) / (st.to_sequence - st.from_sequence) AS relative_position\n    FROM segment_trips st\n    JOIN pid.ropidgtfs_precomputed_departures d\n        ON d.date = st.date\n        AND d.trip_id = st.trip_id\n        AND d.stop_sequence BETWEEN st.from_sequence AND st.to_sequence\n    JOIN pid.ropidgtfs_stops s ON s.stop_id = d.stop_id\n    WHERE s.asw_node_id IS NOT NULL\n),\n-- One row per segment and physical stop (ASW id), positioned for ordering the stops along the segment. The stop is\n-- represented by the first of all its GTFS stop id variants rather than of those served in the time window, so that\n-- the id stays the same between refreshes, which consumers match segments by.\nsegment_stops AS MATERIALIZED (\n    SELECT\n        trip_stops.segment_index,\n        trip_stops.asw_node_id,\n        trip_stops.asw_stop_id,\n        MIN(s.stop_id) AS stop_id,\n        (ARRAY_AGG(s.stop_name ORDER BY s.stop_id))[1] AS stop_name,\n        trip_stops.position\n    FROM (\n        SELECT segment_index, asw_node_id, asw_stop_id, MIN(relative_position) AS position\n        FROM segment_trip_stops\n        GROUP BY segment_index, asw_node_id, asw_stop_id\n    ) trip_stops\n    JOIN pid.ropidgtfs_stops s ON s.asw_node_id = trip_stops.asw_node_id AND s.asw_stop_id = trip_stops.asw_stop_id\n    GROUP BY trip_stops.segment_index, trip_stops.asw_node_id, trip_stops.asw_stop_id, trip_stops.position\n),\n-- Ordered pairs of segment stops (\"earlier>later\" by ASW id) visited in this order by some segment trip. Unlike\n-- comparing positions, this holds for any mix of stopping patterns, e.g. a stop placed differently by two branches.\nsegment_stop_precedences AS MATERIALIZED (\n    SELECT segment_index, jsonb_object_agg(stop_pair, TRUE) AS precedences\n    FROM (\n        SELECT DISTINCT pattern.segment_index, earlier.stop_key || '>' || later.stop_key AS stop_pair\n        FROM (\n            SELECT DISTINCT segment_index, ARRAY_AGG(asw_node_id || '/' || asw_stop_id ORDER BY stop_sequence) AS stop_keys\n            FROM segment_trip_stops\n            GROUP BY segment_index, trip_id, date\n        ) pattern\n        CROSS JOIN LATERAL unnest(pattern.stop_keys) WITH ORDINALITY AS earlier(stop_key, stop_order)\n        JOIN LATERAL unnest(pattern.stop_keys) WITH ORDINALITY AS later(stop_key, stop_order)\n            ON later.stop_order > earlier.stop_order\n    ) stop_pairs\n    GROUP BY segment_index\n),\n-- All GTFS stop ids of the segment stops, so that trips using any variant are recognized\nsegment_stop_variants AS MATERIALIZED (\n    SELECT ss.segment_index, s.stop_id, ss.asw_node_id || '/' || ss.asw_stop_id AS stop_key\n    FROM segment_stops ss\n    JOIN pid.ropidgtfs_stops s ON s.asw_node_id = ss.asw_node_id AND s.asw_stop_id = ss.asw_stop_id\n),\n-- Departures from the segment stops in the time window, fetched once per stop. Otherwise the planner fetches them\n-- again for every pair of segment stops.\nsegment_stop_departures AS MATERIALIZED (\n    SELECT d.trip_id, d.date, d.route_id, d.route_short_name, d.route_type, d.stop_id, d.next_stop_id\n    FROM pid.ropidgtfs_precomputed_departures d\n    WHERE d.stop_id IN (SELECT stop_id FROM segment_stop_variants)\n        AND d.route_id IS NOT NULL\n        AND d.departure_datetime BETWEEN :windowStart AND :windowEnd\n),\n-- ASW ids of the segment stop variants and the stop precedences per segment. Looking the stops up in these small maps\n-- instead of joining them keeps the query fast, as the planner heavily underestimates the row counts of the CTEs and\n-- picks nested loops.\nsegment_lookups AS MATERIALIZED (\n    SELECT variants.segment_index, variants.stop_keys, ssp.precedences\n    FROM (\n        SELECT segment_index, jsonb_object_agg(stop_id, stop_key) AS stop_keys\n        FROM segment_stop_variants\n        GROUP BY segment_index\n    ) variants\n    JOIN segment_stop_precedences ssp ON ssp.segment_index = variants.segment_index\n),\n-- Trips in the time window travelling at least one hop between two segment stops in the segment direction,\n-- unlike segment trips they may join or leave the segment in its middle\naffected_trip_candidates AS MATERIALIZED (\n    SELECT DISTINCT current_stop.segment_index, d.trip_id, d.date, d.route_id, d.route_short_name, d.route_type\n    FROM segment_stop_departures d\n    JOIN segment_stop_variants current_stop ON current_stop.stop_id = d.stop_id\n    JOIN segment_lookups sl ON sl.segment_index = current_stop.segment_index\n    WHERE (sl.precedences -> (current_stop.stop_key || '>' || (sl.stop_keys ->> d.next_stop_id))) IS NOT NULL\n),\n-- Regular affected trips, with the segment stops for the lookups below\naffected_trips AS MATERIALIZED (\n    SELECT atc.*, sl.stop_keys AS segment_stop_keys\n    FROM affected_trip_candidates atc\n    JOIN segment_lookups sl ON sl.segment_index = atc.segment_index\n    WHERE EXISTS (SELECT 1 FROM pid.ropidgtfs_trips t WHERE t.trip_id = atc.trip_id AND t.exceptional = 0)\n),\n-- Stops with a departure preset (info panels) by each GTFS stop id variant of their ASW id. Links to presets that\n-- no longer exist are ignored (the tables are refreshed separately and have no foreign key).\npreset_stop_variants AS MATERIALIZED (\n    SELECT DISTINCT variant.stop_id AS variant_stop_id, preset_stop.stop_id AS preset_stop_id\n    FROM pid.ropid_departures_presets_ropidgtfs_stops ps\n    JOIN pid.ropid_departures_presets p ON p.id = ps.preset_id\n    JOIN pid.ropidgtfs_stops preset_stop ON preset_stop.stop_id = ps.stop_id\n    JOIN pid.ropidgtfs_stops variant\n        ON variant.asw_node_id = preset_stop.asw_node_id AND variant.asw_stop_id = preset_stop.asw_stop_id\n),\n-- First and last stop sequence of each affected trip on the segment.\n-- Distances in stops are computed as differences of stop sequences, which relies on the stop sequences of a trip\n-- being consecutive (true for all PID trips). Ranking all stops of all affected trips instead takes most of the\n-- query time. Should there be gaps, a distance would grow by the gap size.\naffected_trip_bounds AS MATERIALIZED (\n    SELECT\n        at.segment_index,\n        at.trip_id,\n        at.date,\n        at.route_id,\n        MIN(d.stop_sequence) AS first_sequence,\n        MAX(d.stop_sequence) AS last_sequence\n    FROM affected_trips at\n    JOIN pid.ropidgtfs_precomputed_departures d ON d.date = at.date AND d.trip_id = at.trip_id\n    WHERE (at.segment_stop_keys -> d.stop_id) IS NOT NULL\n    GROUP BY at.segment_index, at.trip_id, at.date, at.route_id\n),\n-- Distance of each preset stop from the segment per affected route, up to the max distance: negative before\n-- the segment, 0 on it, positive after it. Of the distances on different trips of a route, the closest is kept.\npreset_stop_distances AS MATERIALIZED (\n    SELECT DISTINCT ON (segment_index, stop_id, route_id) segment_index, stop_id, route_id, distance\n    FROM (\n        SELECT\n            atb.segment_index,\n            preset_stop.preset_stop_id AS stop_id,\n            atb.route_id,\n            CASE\n                WHEN d.stop_sequence < atb.first_sequence THEN d.stop_sequence - atb.first_sequence\n                WHEN d.stop_sequence > atb.last_sequence THEN d.stop_sequence - atb.last_sequence\n                ELSE 0\n            END AS distance\n        FROM affected_trip_bounds atb\n        JOIN pid.ropidgtfs_precomputed_departures d\n            ON d.date = atb.date\n            AND d.trip_id = atb.trip_id\n            AND d.stop_sequence BETWEEN atb.first_sequence - :maxInfoPanelDistanceStops\n                AND atb.last_sequence + :maxInfoPanelDistanceStops\n        JOIN preset_stop_variants preset_stop ON preset_stop.variant_stop_id = d.stop_id\n    ) distances\n    ORDER BY segment_index, stop_id, route_id, ABS(distance), distance\n)\n-- One row per segment with the enrichment as JSON: endpoints, ordered segment stops, affected routes and info panel stops\nSELECT\n    (\n        SELECT COUNT(DISTINCT es.is_from) = 2\n        FROM endpoint_stops es\n        WHERE es.segment_index = seg.segment_index\n    ) AS has_endpoint_stops,\n    (\n        SELECT json_build_object('id', ss.stop_id, 'name', ss.stop_name)\n        FROM segment_stops ss\n        WHERE ss.segment_index = seg.segment_index\n            AND ss.asw_node_id = seg.from_node_id\n            AND ss.asw_stop_id = seg.from_stop_id\n    ) AS from_stop,\n    (\n        SELECT json_build_object('id', ss.stop_id, 'name', ss.stop_name)\n        FROM segment_stops ss\n        WHERE ss.segment_index = seg.segment_index\n            AND ss.asw_node_id = seg.to_node_id\n            AND ss.asw_stop_id = seg.to_stop_id\n    ) AS to_stop,\n    (\n        SELECT COALESCE(json_agg(\n            json_build_object('id', ss.stop_id, 'name', ss.stop_name) ORDER BY ss.position, ss.stop_id\n        ), '[]'::json)\n        FROM segment_stops ss\n        WHERE ss.segment_index = seg.segment_index\n    ) AS stops,\n    (\n        SELECT COALESCE(json_agg(json_build_object(\n            'id', r.route_id,\n            'short_name', r.route_short_name,\n            'type', r.route_type\n        ) ORDER BY r.route_id), '[]'::json)\n        FROM (\n            SELECT DISTINCT route_id, route_short_name, route_type\n            FROM affected_trips\n            WHERE segment_index = seg.segment_index\n        ) r\n    ) AS routes,\n    (\n        SELECT COALESCE(json_agg(json_build_object(\n            'stop', json_build_object('id', s.stop_id, 'name', s.stop_name),\n            'preset_route_names', (\n                SELECT json_agg(DISTINCT p.route_name ORDER BY p.route_name)\n                FROM pid.ropid_departures_presets_ropidgtfs_stops ps\n                JOIN pid.ropid_departures_presets p ON p.id = ps.preset_id\n                WHERE ps.stop_id = s.stop_id\n            ),\n            'routes', (\n                SELECT json_agg(json_build_object('id', psd.route_id, 'distance_stops', psd.distance) ORDER BY psd.route_id)\n                FROM preset_stop_distances psd\n                WHERE psd.segment_index = seg.segment_index AND psd.stop_id = s.stop_id\n            )\n        ) ORDER BY s.stop_id), '[]'::json)\n        FROM pid.ropidgtfs_stops s\n        WHERE s.stop_id IN (SELECT psd.stop_id FROM preset_stop_distances psd WHERE psd.segment_index = seg.segment_index)\n    ) AS info_panel_stops\nFROM segments seg\nORDER BY seg.segment_index\n";

package/dist/integration-engine/jis/repositories/helpers/JISDelayedSegmentEnrichmentQuery.js

@@ -0,0 +1,266 @@
+import { PG_SCHEMA } from "#sch/const";
+/**
+ * Enriches delayed segments given by the ASW ids of their endpoints with their stops, affected routes and info panel
+ * stops. All segments of a refresh are enriched by one query, so that planning and lookups shared by the segments
+ * are done only once.
+ *
+ * Replacements: segments (JSON array of objects with segment_index, from_node_id, from_stop_id, to_node_id and
+ * to_stop_id), windowStart, windowEnd (departures taken into account) and maxInfoPanelDistanceStops (max distance
+ * of an info panel stop from the segment).
+ *
+ * Returns one row per segment, ordered by segment_index. Stops are matched by ASW id rather than by GTFS stop_id,
+ * since one physical stop can have several GTFS stop ids (zone and temporary variants).
+ */
+export const JIS_DELAYED_SEGMENT_ENRICHMENT_QUERY = `
+WITH
+segments AS MATERIALIZED (
+    SELECT *
+    FROM jsonb_to_recordset(CAST(:segments AS jsonb))
+        AS segment(segment_index int, from_node_id int, from_stop_id int, to_node_id int, to_stop_id int)
+),
+-- GTFS stop ids of the segment endpoints, all variants of their ASW ids
+endpoint_stops AS MATERIALIZED (
+    SELECT seg.segment_index, TRUE AS is_from, s.stop_id
+    FROM segments seg
+    JOIN ${PG_SCHEMA}.ropidgtfs_stops s ON s.asw_node_id = seg.from_node_id AND s.asw_stop_id = seg.from_stop_id
+    UNION ALL
+    SELECT seg.segment_index, FALSE AS is_from, s.stop_id
+    FROM segments seg
+    JOIN ${PG_SCHEMA}.ropidgtfs_stops s ON s.asw_node_id = seg.to_node_id AND s.asw_stop_id = seg.to_stop_id
+),
+-- Regular trips in the time window running the whole segment, they define which stops lie on the segment
+segment_trips AS MATERIALIZED (
+    SELECT DISTINCT
+        from_stop.segment_index,
+        d_from.trip_id,
+        d_from.date,
+        d_from.stop_sequence AS from_sequence,
+        d_to.stop_sequence AS to_sequence
+    FROM endpoint_stops from_stop
+    JOIN ${PG_SCHEMA}.ropidgtfs_precomputed_departures d_from
+        ON d_from.stop_id = from_stop.stop_id
+        AND d_from.departure_datetime BETWEEN :windowStart AND :windowEnd
+    JOIN ${PG_SCHEMA}.ropidgtfs_precomputed_departures d_to
+        ON d_to.date = d_from.date
+        AND d_to.trip_id = d_from.trip_id
+        AND d_to.stop_sequence > d_from.stop_sequence
+    JOIN endpoint_stops to_stop
+        ON to_stop.segment_index = from_stop.segment_index
+        AND NOT to_stop.is_from
+        AND to_stop.stop_id = d_to.stop_id
+    JOIN ${PG_SCHEMA}.ropidgtfs_trips t ON t.trip_id = d_from.trip_id AND t.exceptional = 0
+    WHERE from_stop.is_from
+),
+-- Stops between the endpoints along each segment trip, with their position relative to the trip's run of the segment
+-- (0 at the start, 1 at the end), so that trips skipping stops agree on the positions of the stops they share
+segment_trip_stops AS MATERIALIZED (
+    SELECT
+        st.segment_index,
+        st.trip_id,
+        st.date,
+        d.stop_sequence,
+        s.stop_id,
+        s.stop_name,
+        s.asw_node_id,
+        s.asw_stop_id,
+        CAST(d.stop_sequence - st.from_sequence AS numeric) / (st.to_sequence - st.from_sequence) AS relative_position
+    FROM segment_trips st
+    JOIN ${PG_SCHEMA}.ropidgtfs_precomputed_departures d
+        ON d.date = st.date
+        AND d.trip_id = st.trip_id
+        AND d.stop_sequence BETWEEN st.from_sequence AND st.to_sequence
+    JOIN ${PG_SCHEMA}.ropidgtfs_stops s ON s.stop_id = d.stop_id
+    WHERE s.asw_node_id IS NOT NULL
+),
+-- One row per segment and physical stop (ASW id), positioned for ordering the stops along the segment. The stop is
+-- represented by the first of all its GTFS stop id variants rather than of those served in the time window, so that
+-- the id stays the same between refreshes, which consumers match segments by.
+segment_stops AS MATERIALIZED (
+    SELECT
+        trip_stops.segment_index,
+        trip_stops.asw_node_id,
+        trip_stops.asw_stop_id,
+        MIN(s.stop_id) AS stop_id,
+        (ARRAY_AGG(s.stop_name ORDER BY s.stop_id))[1] AS stop_name,
+        trip_stops.position
+    FROM (
+        SELECT segment_index, asw_node_id, asw_stop_id, MIN(relative_position) AS position
+        FROM segment_trip_stops
+        GROUP BY segment_index, asw_node_id, asw_stop_id
+    ) trip_stops
+    JOIN ${PG_SCHEMA}.ropidgtfs_stops s ON s.asw_node_id = trip_stops.asw_node_id AND s.asw_stop_id = trip_stops.asw_stop_id
+    GROUP BY trip_stops.segment_index, trip_stops.asw_node_id, trip_stops.asw_stop_id, trip_stops.position
+),
+-- Ordered pairs of segment stops ("earlier>later" by ASW id) visited in this order by some segment trip. Unlike
+-- comparing positions, this holds for any mix of stopping patterns, e.g. a stop placed differently by two branches.
+segment_stop_precedences AS MATERIALIZED (
+    SELECT segment_index, jsonb_object_agg(stop_pair, TRUE) AS precedences
+    FROM (
+        SELECT DISTINCT pattern.segment_index, earlier.stop_key || '>' || later.stop_key AS stop_pair
+        FROM (
+            SELECT DISTINCT segment_index, ARRAY_AGG(asw_node_id || '/' || asw_stop_id ORDER BY stop_sequence) AS stop_keys
+            FROM segment_trip_stops
+            GROUP BY segment_index, trip_id, date
+        ) pattern
+        CROSS JOIN LATERAL unnest(pattern.stop_keys) WITH ORDINALITY AS earlier(stop_key, stop_order)
+        JOIN LATERAL unnest(pattern.stop_keys) WITH ORDINALITY AS later(stop_key, stop_order)
+            ON later.stop_order > earlier.stop_order
+    ) stop_pairs
+    GROUP BY segment_index
+),
+-- All GTFS stop ids of the segment stops, so that trips using any variant are recognized
+segment_stop_variants AS MATERIALIZED (
+    SELECT ss.segment_index, s.stop_id, ss.asw_node_id || '/' || ss.asw_stop_id AS stop_key
+    FROM segment_stops ss
+    JOIN ${PG_SCHEMA}.ropidgtfs_stops s ON s.asw_node_id = ss.asw_node_id AND s.asw_stop_id = ss.asw_stop_id
+),
+-- Departures from the segment stops in the time window, fetched once per stop. Otherwise the planner fetches them
+-- again for every pair of segment stops.
+segment_stop_departures AS MATERIALIZED (
+    SELECT d.trip_id, d.date, d.route_id, d.route_short_name, d.route_type, d.stop_id, d.next_stop_id
+    FROM ${PG_SCHEMA}.ropidgtfs_precomputed_departures d
+    WHERE d.stop_id IN (SELECT stop_id FROM segment_stop_variants)
+        AND d.route_id IS NOT NULL
+        AND d.departure_datetime BETWEEN :windowStart AND :windowEnd
+),
+-- ASW ids of the segment stop variants and the stop precedences per segment. Looking the stops up in these small maps
+-- instead of joining them keeps the query fast, as the planner heavily underestimates the row counts of the CTEs and
+-- picks nested loops.
+segment_lookups AS MATERIALIZED (
+    SELECT variants.segment_index, variants.stop_keys, ssp.precedences
+    FROM (
+        SELECT segment_index, jsonb_object_agg(stop_id, stop_key) AS stop_keys
+        FROM segment_stop_variants
+        GROUP BY segment_index
+    ) variants
+    JOIN segment_stop_precedences ssp ON ssp.segment_index = variants.segment_index
+),
+-- Trips in the time window travelling at least one hop between two segment stops in the segment direction,
+-- unlike segment trips they may join or leave the segment in its middle
+affected_trip_candidates AS MATERIALIZED (
+    SELECT DISTINCT current_stop.segment_index, d.trip_id, d.date, d.route_id, d.route_short_name, d.route_type
+    FROM segment_stop_departures d
+    JOIN segment_stop_variants current_stop ON current_stop.stop_id = d.stop_id
+    JOIN segment_lookups sl ON sl.segment_index = current_stop.segment_index
+    WHERE (sl.precedences -> (current_stop.stop_key || '>' || (sl.stop_keys ->> d.next_stop_id))) IS NOT NULL
+),
+-- Regular affected trips, with the segment stops for the lookups below
+affected_trips AS MATERIALIZED (
+    SELECT atc.*, sl.stop_keys AS segment_stop_keys
+    FROM affected_trip_candidates atc
+    JOIN segment_lookups sl ON sl.segment_index = atc.segment_index
+    WHERE EXISTS (SELECT 1 FROM ${PG_SCHEMA}.ropidgtfs_trips t WHERE t.trip_id = atc.trip_id AND t.exceptional = 0)
+),
+-- Stops with a departure preset (info panels) by each GTFS stop id variant of their ASW id. Links to presets that
+-- no longer exist are ignored (the tables are refreshed separately and have no foreign key).
+preset_stop_variants AS MATERIALIZED (
+    SELECT DISTINCT variant.stop_id AS variant_stop_id, preset_stop.stop_id AS preset_stop_id
+    FROM ${PG_SCHEMA}.ropid_departures_presets_ropidgtfs_stops ps
+    JOIN ${PG_SCHEMA}.ropid_departures_presets p ON p.id = ps.preset_id
+    JOIN ${PG_SCHEMA}.ropidgtfs_stops preset_stop ON preset_stop.stop_id = ps.stop_id
+    JOIN ${PG_SCHEMA}.ropidgtfs_stops variant
+        ON variant.asw_node_id = preset_stop.asw_node_id AND variant.asw_stop_id = preset_stop.asw_stop_id
+),
+-- First and last stop sequence of each affected trip on the segment.
+-- Distances in stops are computed as differences of stop sequences, which relies on the stop sequences of a trip
+-- being consecutive (true for all PID trips). Ranking all stops of all affected trips instead takes most of the
+-- query time. Should there be gaps, a distance would grow by the gap size.
+affected_trip_bounds AS MATERIALIZED (
+    SELECT
+        at.segment_index,
+        at.trip_id,
+        at.date,
+        at.route_id,
+        MIN(d.stop_sequence) AS first_sequence,
+        MAX(d.stop_sequence) AS last_sequence
+    FROM affected_trips at
+    JOIN ${PG_SCHEMA}.ropidgtfs_precomputed_departures d ON d.date = at.date AND d.trip_id = at.trip_id
+    WHERE (at.segment_stop_keys -> d.stop_id) IS NOT NULL
+    GROUP BY at.segment_index, at.trip_id, at.date, at.route_id
+),
+-- Distance of each preset stop from the segment per affected route, up to the max distance: negative before
+-- the segment, 0 on it, positive after it. Of the distances on different trips of a route, the closest is kept.
+preset_stop_distances AS MATERIALIZED (
+    SELECT DISTINCT ON (segment_index, stop_id, route_id) segment_index, stop_id, route_id, distance
+    FROM (
+        SELECT
+            atb.segment_index,
+            preset_stop.preset_stop_id AS stop_id,
+            atb.route_id,
+            CASE
+                WHEN d.stop_sequence < atb.first_sequence THEN d.stop_sequence - atb.first_sequence
+                WHEN d.stop_sequence > atb.last_sequence THEN d.stop_sequence - atb.last_sequence
+                ELSE 0
+            END AS distance
+        FROM affected_trip_bounds atb
+        JOIN ${PG_SCHEMA}.ropidgtfs_precomputed_departures d
+            ON d.date = atb.date
+            AND d.trip_id = atb.trip_id
+            AND d.stop_sequence BETWEEN atb.first_sequence - :maxInfoPanelDistanceStops
+                AND atb.last_sequence + :maxInfoPanelDistanceStops
+        JOIN preset_stop_variants preset_stop ON preset_stop.variant_stop_id = d.stop_id
+    ) distances
+    ORDER BY segment_index, stop_id, route_id, ABS(distance), distance
+)
+-- One row per segment with the enrichment as JSON: endpoints, ordered segment stops, affected routes and info panel stops
+SELECT
+    (
+        SELECT COUNT(DISTINCT es.is_from) = 2
+        FROM endpoint_stops es
+        WHERE es.segment_index = seg.segment_index
+    ) AS has_endpoint_stops,
+    (
+        SELECT json_build_object('id', ss.stop_id, 'name', ss.stop_name)
+        FROM segment_stops ss
+        WHERE ss.segment_index = seg.segment_index
+            AND ss.asw_node_id = seg.from_node_id
+            AND ss.asw_stop_id = seg.from_stop_id
+    ) AS from_stop,
+    (
+        SELECT json_build_object('id', ss.stop_id, 'name', ss.stop_name)
+        FROM segment_stops ss
+        WHERE ss.segment_index = seg.segment_index
+            AND ss.asw_node_id = seg.to_node_id
+            AND ss.asw_stop_id = seg.to_stop_id
+    ) AS to_stop,
+    (
+        SELECT COALESCE(json_agg(
+            json_build_object('id', ss.stop_id, 'name', ss.stop_name) ORDER BY ss.position, ss.stop_id
+        ), '[]'::json)
+        FROM segment_stops ss
+        WHERE ss.segment_index = seg.segment_index
+    ) AS stops,
+    (
+        SELECT COALESCE(json_agg(json_build_object(
+            'id', r.route_id,
+            'short_name', r.route_short_name,
+            'type', r.route_type
+        ) ORDER BY r.route_id), '[]'::json)
+        FROM (
+            SELECT DISTINCT route_id, route_short_name, route_type
+            FROM affected_trips
+            WHERE segment_index = seg.segment_index
+        ) r
+    ) AS routes,
+    (
+        SELECT COALESCE(json_agg(json_build_object(
+            'stop', json_build_object('id', s.stop_id, 'name', s.stop_name),
+            'preset_route_names', (
+                SELECT json_agg(DISTINCT p.route_name ORDER BY p.route_name)
+                FROM ${PG_SCHEMA}.ropid_departures_presets_ropidgtfs_stops ps
+                JOIN ${PG_SCHEMA}.ropid_departures_presets p ON p.id = ps.preset_id
+                WHERE ps.stop_id = s.stop_id
+            ),
+            'routes', (
+                SELECT json_agg(json_build_object('id', psd.route_id, 'distance_stops', psd.distance) ORDER BY psd.route_id)
+                FROM preset_stop_distances psd
+                WHERE psd.segment_index = seg.segment_index AND psd.stop_id = s.stop_id
+            )
+        ) ORDER BY s.stop_id), '[]'::json)
+        FROM ${PG_SCHEMA}.ropidgtfs_stops s
+        WHERE s.stop_id IN (SELECT psd.stop_id FROM preset_stop_distances psd WHERE psd.segment_index = seg.segment_index)
+    ) AS info_panel_stops
+FROM segments seg
+ORDER BY seg.segment_index
+`;
+//# sourceMappingURL=JISDelayedSegmentEnrichmentQuery.js.map

package/dist/integration-engine/jis/repositories/helpers/JISDelayedSegmentEnrichmentQuery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"JISDelayedSegmentEnrichmentQuery.js","sourceRoot":"","sources":["../../../../../src/integration-engine/jis/repositories/helpers/JISDelayedSegmentEnrichmentQuery.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAEvC;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,oCAAoC,GAAG;;;;;;;;;;;WAWzC,SAAS;;;;WAIT,SAAS;;;;;;;;;;;WAWT,SAAS;;;WAGT,SAAS;;;;;;;;WAQT,SAAS;;;;;;;;;;;;;;;;;WAiBT,SAAS;;;;WAIT,SAAS;;;;;;;;;;;;;;;;;;;WAmBT,SAAS;;;;;;;;;;;;;;;;;;;;;;;;WAwBT,SAAS;;;;;;WAMT,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCA+Bc,SAAS;;;;;;WAMhC,SAAS;WACT,SAAS;WACT,SAAS;WACT,SAAS;;;;;;;;;;;;;;;;WAgBT,SAAS;;;;;;;;;;;;;;;;;;;eAmBL,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAsDD,SAAS;uBACT,SAAS;;;;;;;;;eASjB,SAAS;;;;;CAKvB,CAAC"}

package/dist/integration-engine/jis/repositories/interfaces/IJISDelayedSegmentEnrichmentParams.d.ts

@@ -0,0 +1,23 @@
+/**
+ * ASW id of a stop: node (uzel) and stop (sloupek)
+ */
+export interface IAswStopId {
+    nodeId: number;
+    stopId: number;
+}
+/**
+ * Endpoints of a delayed segment as ASW ids
+ */
+export interface IAswSegmentEndpoints {
+    from: IAswStopId;
+    to: IAswStopId;
+}
+/**
+ * Delayed segments to enrich and the parameters of the enrichment
+ */
+export interface IJISDelayedSegmentEnrichmentParams {
+    segments: IAswSegmentEndpoints[];
+    windowStart: Date;
+    windowEnd: Date;
+    maxInfoPanelDistanceStops: number;
+}

package/dist/integration-engine/jis/repositories/interfaces/IJISDelayedSegmentEnrichmentParams.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IJISDelayedSegmentEnrichmentParams.js.map

package/dist/integration-engine/jis/repositories/interfaces/IJISDelayedSegmentEnrichmentParams.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IJISDelayedSegmentEnrichmentParams.js","sourceRoot":"","sources":["../../../../../src/integration-engine/jis/repositories/interfaces/IJISDelayedSegmentEnrichmentParams.ts"],"names":[],"mappings":""}

package/dist/integration-engine/jis/services/JISDelayedSegmentsDataService.d.ts

@@ -0,0 +1,38 @@
+import { JISDelayedSegmentEnrichmentRepository } from "#ie/jis/repositories/JISDelayedSegmentEnrichmentRepository";
+import { JISDelayedSegmentsRepository } from "#ie/jis/repositories/JISDelayedSegmentsRepository";
+import { type IMapaPidDelayShape } from "#sch/jis/datasources/interfaces/index";
+import { type ISimpleConfig } from "@golemio/core/dist/helpers/configuration/ISimpleConfig.js";
+import { type ILogger } from "@golemio/core/dist/helpers/index.js";
+/**
+ * Turns delayed segments detected by Mapa PID into delayed segments enriched with GTFS data and stores them
+ */
+export declare class JISDelayedSegmentsDataService {
+    private enrichmentRepository;
+    private delayedSegmentsRepository;
+    private logger;
+    private readonly minDelaySeconds;
+    private readonly routeTimeWindowMinutes;
+    private readonly maxInfoPanelDistanceStops;
+    constructor(enrichmentRepository: JISDelayedSegmentEnrichmentRepository, delayedSegmentsRepository: JISDelayedSegmentsRepository, config: ISimpleConfig, logger: ILogger);
+    /**
+     * Replaces stored delayed segments with the given detected ones. Segments below the minimum delay, segments whose
+     * endpoints cannot be mapped to GTFS stops, segments no trip runs as a whole and segments without any affected
+     * route are skipped and counted by reason.
+     */
+    refreshDelayedSegments(delayShapes: IMapaPidDelayShape[], detectedAt: Date): Promise<void>;
+    /**
+     * Significant delay shapes with endpoints mapped to ASW ids
+     */
+    private getCandidates;
+    /**
+     * Enrichments of the candidates by segment id, derived once per segment
+     */
+    private getEnrichments;
+    private parseAswStopId;
+    private isValidAswIdPart;
+    /**
+     * Skipped segments are logged only at the debug level, as they repeat every refresh while the delay lasts
+     */
+    private skip;
+    private toDelayedSegment;
+}

package/dist/integration-engine/jis/services/JISDelayedSegmentsDataService.js

@@ -0,0 +1,174 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { GtfsStopParser } from "#helpers/GtfsStopParser";
+import { JISContainerToken } from "#ie/jis/ioc/JISContainerToken";
+import { JISDelayedSegmentEnrichmentRepository } from "#ie/jis/repositories/JISDelayedSegmentEnrichmentRepository";
+import { JISDelayedSegmentsRepository } from "#ie/jis/repositories/JISDelayedSegmentsRepository";
+import { CoreToken } from "@golemio/core/dist/helpers/ioc/CoreToken.js";
+import GolemioErrorsCore from "@golemio/core/dist/shared/golemio-errors.js";
+const { GeneralError } = GolemioErrorsCore;
+import { inject, injectable } from "@golemio/core/dist/shared/tsyringe.js";
+import { PG_INT_MAX } from "../../../const.js";
+const MINUTE_IN_MS = 60 * 1000;
+var SkipReason;
+(function (SkipReason) {
+    SkipReason["BelowMinimumDelay"] = "below minimum delay";
+    SkipReason["NoAswIds"] = "no ASW ids";
+    SkipReason["EndpointStopsNotInGtfs"] = "endpoint stops not in GTFS";
+    // Mapa PID merges adjacent delayed sections regardless of the lines running them
+    SkipReason["NoTripRunsWholeSegment"] = "no trip runs the whole segment";
+    SkipReason["NoAffectedRoutes"] = "no affected routes";
+})(SkipReason || (SkipReason = {}));
+/**
+ * Turns delayed segments detected by Mapa PID into delayed segments enriched with GTFS data and stores them
+ */
+let JISDelayedSegmentsDataService = class JISDelayedSegmentsDataService {
+    constructor(enrichmentRepository, delayedSegmentsRepository, config, logger) {
+        this.enrichmentRepository = enrichmentRepository;
+        this.delayedSegmentsRepository = delayedSegmentsRepository;
+        this.logger = logger;
+        this.minDelaySeconds = Number(config.getValue("module.pid.jis.delayedSegments.minDelaySeconds", 300));
+        this.routeTimeWindowMinutes = Number(config.getValue("module.pid.jis.delayedSegments.routeTimeWindowMinutes", 120));
+        this.maxInfoPanelDistanceStops = Number(config.getValue("module.pid.jis.delayedSegments.maxInfoPanelDistanceStops", 5));
+    }
+    /**
+     * Replaces stored delayed segments with the given detected ones. Segments below the minimum delay, segments whose
+     * endpoints cannot be mapped to GTFS stops, segments no trip runs as a whole and segments without any affected
+     * route are skipped and counted by reason.
+     */
+    async refreshDelayedSegments(delayShapes, detectedAt) {
+        const skipCounts = new Map();
+        const candidates = this.getCandidates(delayShapes, skipCounts);
+        const enrichments = await this.getEnrichments(candidates, detectedAt);
+        const segments = new Map();
+        for (const candidate of candidates) {
+            const enrichment = enrichments.get(candidate.id);
+            if (!enrichment) {
+                throw new GeneralError(`Missing enrichment of delayed segment ${candidate.id}`, this.constructor.name);
+            }
+            const segment = this.toDelayedSegment(candidate, enrichment);
+            if (typeof segment === "string") {
+                this.skip(skipCounts, segment, candidate.id);
+                continue;
+            }
+            // stop id variants of one physical stop may result in duplicate segments, the biggest delay wins
+            const duplicate = segments.get(segment.id);
+            if (!duplicate || duplicate.expected_delay_seconds < segment.expected_delay_seconds) {
+                segments.set(segment.id, segment);
+            }
+        }
+        await this.delayedSegmentsRepository.refreshData(Array.from(segments.values()), detectedAt);
+        const skipped = Array.from(skipCounts, ([reason, count]) => `${reason} ${count}`).join(", ") || "none";
+        this.logger.info(`${this.constructor.name}: stored ${segments.size} of ${delayShapes.length} delayed segments, skipped: ${skipped}.`);
+    }
+    /**
+     * Significant delay shapes with endpoints mapped to ASW ids
+     */
+    getCandidates(delayShapes, skipCounts) {
+        const candidates = [];
+        for (const delayShape of delayShapes) {
+            if (delayShape.expected_delay < this.minDelaySeconds) {
+                skipCounts.set(SkipReason.BelowMinimumDelay, (skipCounts.get(SkipReason.BelowMinimumDelay) ?? 0) + 1);
+                continue;
+            }
+            const from = this.parseAswStopId(delayShape.from_stop_id);
+            const to = this.parseAswStopId(delayShape.to_stop_id);
+            if (!from || !to) {
+                this.skip(skipCounts, SkipReason.NoAswIds, `${delayShape.from_stop_id} -> ${delayShape.to_stop_id}`);
+                continue;
+            }
+            candidates.push({
+                id: `${from.nodeId}/${from.stopId}-${to.nodeId}/${to.stopId}`,
+                delayShape,
+                endpoints: { from, to },
+            });
+        }
+        return candidates;
+    }
+    /**
+     * Enrichments of the candidates by segment id, derived once per segment
+     */
+    async getEnrichments(candidates, detectedAt) {
+        const endpointsToEnrich = new Map();
+        for (const candidate of candidates) {
+            endpointsToEnrich.set(candidate.id, candidate.endpoints);
+        }
+        const windowInMs = this.routeTimeWindowMinutes * MINUTE_IN_MS;
+        const newEnrichments = await this.enrichmentRepository.getEnrichments({
+            segments: Array.from(endpointsToEnrich.values()),
+            windowStart: new Date(detectedAt.getTime() - windowInMs),
+            windowEnd: new Date(detectedAt.getTime() + windowInMs),
+            maxInfoPanelDistanceStops: this.maxInfoPanelDistanceStops,
+        });
+        const enrichments = new Map();
+        for (const [index, id] of Array.from(endpointsToEnrich.keys()).entries()) {
+            const enrichment = newEnrichments[index];
+            if (enrichment) {
+                enrichments.set(id, enrichment);
+            }
+        }
+        return enrichments;
+    }
+    parseAswStopId(stopId) {
+        const [nodeId, aswStopId] = GtfsStopParser.normalizedStopId(stopId).split("/").map(Number);
+        if (!this.isValidAswIdPart(nodeId) || !this.isValidAswIdPart(aswStopId)) {
+            return null;
+        }
+        return { nodeId, stopId: aswStopId };
+    }
+    isValidAswIdPart(value) {
+        return value !== undefined && Number.isInteger(value) && value >= 0 && value <= PG_INT_MAX;
+    }
+    /**
+     * Skipped segments are logged only at the debug level, as they repeat every refresh while the delay lasts
+     */
+    skip(skipCounts, reason, segment) {
+        skipCounts.set(reason, (skipCounts.get(reason) ?? 0) + 1);
+        this.logger.debug(`${this.constructor.name}: skipping segment ${segment} (${reason}).`);
+    }
+    toDelayedSegment(candidate, enrichment) {
+        if (!enrichment.has_endpoint_stops) {
+            return SkipReason.EndpointStopsNotInGtfs;
+        }
+        if (!enrichment.from_stop || !enrichment.to_stop) {
+            return SkipReason.NoTripRunsWholeSegment;
+        }
+        if (enrichment.routes.length === 0) {
+            return SkipReason.NoAffectedRoutes;
+        }
+        return {
+            id: candidate.id,
+            external_from_stop_id: candidate.delayShape.from_stop_id,
+            external_to_stop_id: candidate.delayShape.to_stop_id,
+            from_stop_id: enrichment.from_stop.id,
+            from_stop_name: enrichment.from_stop.name,
+            to_stop_id: enrichment.to_stop.id,
+            to_stop_name: enrichment.to_stop.name,
+            expected_delay_seconds: candidate.delayShape.expected_delay,
+            stops: enrichment.stops,
+            routes: enrichment.routes,
+            info_panel_stops: enrichment.info_panel_stops,
+        };
+    }
+};
+JISDelayedSegmentsDataService = __decorate([
+    injectable(),
+    __param(0, inject(JISContainerToken.JISDelayedSegmentEnrichmentRepository)),
+    __param(1, inject(JISContainerToken.JISDelayedSegmentsRepository)),
+    __param(2, inject(CoreToken.SimpleConfig)),
+    __param(3, inject(CoreToken.Logger)),
+    __metadata("design:paramtypes", [JISDelayedSegmentEnrichmentRepository,
+        JISDelayedSegmentsRepository, Object, Object])
+], JISDelayedSegmentsDataService);
+export { JISDelayedSegmentsDataService };
+//# sourceMappingURL=JISDelayedSegmentsDataService.js.map

package/dist/integration-engine/jis/services/JISDelayedSegmentsDataService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"JISDelayedSegmentsDataService.js","sourceRoot":"","sources":["../../../../src/integration-engine/jis/services/JISDelayedSegmentsDataService.ts"],"names":[],"mappings":"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"}