@fabriktor/fx 0.0.138 → 0.0.140

package/dist/src/routes/planning.js

@@ -0,0 +1,101 @@
+import { isValidInputDate, minutesOfDay, sameCalendarDay, } from "../core/date.js";
+import { errValidation } from "../core/err.js";
+import { normalizeIDs, resolvedID } from "../core/id.js";
+import { routeInput, validateRouteTimeWindow } from "./validation.js";
+import { PreActionBlocked } from "../core/pre-action.js";
+const routePreparationBlocked = "route_preparation";
+const msgPlanningLocation = "Select an active location with a client and a saved address.";
+const msgPlanningEmployees = "Choose available employees who are not already in another vehicle.";
+export const RouteMutationBlock = {
+    Busy: "route_mutation_busy",
+    Changed: "route_mutation_changed",
+    Unconfirmed: "route_mutation_unconfirmed",
+};
+// Compare only editable fields. Vehicle IDs and itineraries belong to Go.
+export function routePlanChanged(current, input) {
+    return (input.override_itinerary ||
+        JSON.stringify({
+            ...routeInput(current),
+            override_itinerary: false,
+        }) !== JSON.stringify({ ...routeInput(input), override_itinerary: false }));
+}
+export class RoutePreparationBlocked extends PreActionBlocked {
+    cause;
+    constructor(cause) {
+        super(routePreparationBlocked);
+        this.cause = cause;
+    }
+}
+export const routePlanningDefaults = {
+    days_ago: 0,
+    duration_in_minutes: 0,
+    consider_traffic: false,
+    start_early: false,
+    override_itinerary: false,
+};
+export function newRoutePlan(opts) {
+    return {
+        timezone: opts.day.tz,
+        from: { ...opts.day, h: opts.company.work_day_start_hour, min: 0 },
+        to: { ...opts.day, h: opts.company.work_day_end_hour, min: 0 },
+        start_place_id: opts.start_place_id,
+        vehicles: [],
+        destinations: [],
+        consider_traffic: routePlanningDefaults.consider_traffic,
+        start_early: routePlanningDefaults.start_early,
+        override_itinerary: routePlanningDefaults.override_itinerary,
+    };
+}
+export function routeDestination(location, owner_id) {
+    if (location.owner_id !== owner_id ||
+        location.is_archived ||
+        !location.place_id.trim() ||
+        !resolvedID(location.client_id))
+        throw errValidation({
+            field: "destinations",
+            msg: msgPlanningLocation,
+        });
+    return {
+        location_id: location.id,
+        client_id: location.client_id,
+        place_id: location.place_id,
+        tags: [],
+        duration_in_minutes: routePlanningDefaults.duration_in_minutes,
+        use_time_window: false,
+        time_window_start_hour_in_minutes: 0,
+        time_window_end_hour_in_minutes: 0,
+    };
+}
+export function validateRouteEmployees(ids, allowed, occupied = []) {
+    const available = new Set(allowed);
+    const used = new Set(occupied);
+    if (!ids.length ||
+        normalizeIDs(ids).length !== ids.length ||
+        ids.some((id) => !available.has(id) || used.has(id)))
+        throw errValidation({
+            field: "vehicles",
+            msg: msgPlanningEmployees,
+        });
+}
+// Suggestions are child data in an availability response. Intersect the client's
+// window with the route window; never widen the hours offered by either party.
+export function routeAvailabilityWindows(input, availability, location_id, client_id) {
+    validateRouteTimeWindow(input);
+    return availability.client_availabilities
+        .flatMap((group) => group.location_id === location_id ? group.availabilities : [])
+        .flatMap((window) => {
+        if (window.owner_id !== client_id ||
+            window.location_id !== location_id ||
+            window.timezone !== input.timezone ||
+            window.from.tz !== input.timezone ||
+            window.to.tz !== input.timezone ||
+            !isValidInputDate(window.from) ||
+            !isValidInputDate(window.to) ||
+            !sameCalendarDay(window.from, input.from) ||
+            !sameCalendarDay(window.to, input.to))
+            return [];
+        const start = Math.max(minutesOfDay(window.from), minutesOfDay(input.from));
+        const end = Math.min(minutesOfDay(window.to), minutesOfDay(input.to));
+        return start < end ? [{ availability: window, start, end }] : [];
+    });
+}

package/dist/src/routes/punch.d.ts

@@ -0,0 +1,9 @@
+import type { JobsOperator, RoutesOperator } from "@fabriktor/client";
+import { type Location } from "@fabriktor/schema";
+import { type RoutesActor } from "./workspace.js";
+export declare function loadRoutePunchLocation(routes: RoutesOperator, jobs: JobsOperator, opts: {
+    actor: RoutesActor;
+    route_id: string;
+    vehicle_id: string;
+    location_id: string;
+}): Promise<Location>;

package/dist/src/routes/punch.js

@@ -0,0 +1,23 @@
+import { UserTypeEmployee } from "@fabriktor/schema";
+import { errValidation } from "../core/err.js";
+import { routeCanTrack } from "./workspace.js";
+const msgRoutePunch = "This destination is no longer available on the assigned route.";
+export async function loadRoutePunchLocation(routes, jobs, opts) {
+    const route = (await routes.findOneRoute({ id: opts.route_id })).value;
+    if (!route ||
+        opts.actor.active_mode !== UserTypeEmployee ||
+        !routeCanTrack(opts.actor, route, opts.vehicle_id, opts.actor.owner_id) ||
+        !route.itinerary.routes
+            .find((v) => v.vehicle_id === opts.vehicle_id)
+            ?.stops.some((s) => s.location_id === opts.location_id))
+        throw errValidation({ msg: msgRoutePunch });
+    const location = (await jobs.findOneLocation({ id: opts.location_id })).value;
+    const destination = route.destinations.find((value) => value.location_id === opts.location_id);
+    if (!location ||
+        location.is_archived ||
+        location.owner_id !== route.owner_id ||
+        !destination ||
+        location.place_id !== destination.place_id)
+        throw errValidation({ msg: msgRoutePunch });
+    return location;
+}

package/dist/src/routes/routes.d.ts

@@ -1,5 +1,7 @@
 import type { RoutesOperator } from "@fabriktor/client";
-import type { ClientAvailability, Route, RouteTeam, Tag, Tracking } from "@fabriktor/schema";
+import type { ClientAvailability, InRoute, Route, RouteTeam, RPRoutesAvailability, Tag, Tracking } from "@fabriktor/schema";
+import { RoutesWorkspace, type PrepareRouteOptions, type RoutesActor } from "./workspace.js";
+import type { MultiCreateCheckpoint, MultiCreateAttempt } from "../core/multi-create.js";
 import { type OwnerSearchOptions, type SearchPage } from "../core/search.js";
 type RouteInsertOptions = Parameters<RoutesOperator["insertOneRoute"]>[0];
 type RouteReplaceOptions = Parameters<RoutesOperator["replaceOneRoute"]>[0];
@@ -11,24 +13,39 @@ type TrackingInsertOptions = Parameters<RoutesOperator["insertOneTracking"]>[0];
 type TrackingReplaceOptions = Parameters<RoutesOperator["replaceOneTracking"]>[0];
 type RouteTeamInsertOptions = Parameters<RoutesOperator["insertOneRouteTeam"]>[0];
 type RouteTeamReplaceOptions = Parameters<RoutesOperator["replaceOneRouteTeam"]>[0];
-type RouteInsert = RouteInsertOptions["in"];
 type RouteAvailability = NonNullable<Awaited<ReturnType<RoutesOperator["getAvailability"]>>["value"]>;
-export type CreateRouteOptions = {
-    in: RouteInsert;
+export type CreateRouteOptions = RouteInsertOptions & Pick<MultiCreateCheckpoint, "before_request" | "on_created"> & {
     availability: RouteAvailability;
 };
 export type CreateValidatedRouteResult = Awaited<ReturnType<RoutesOperator["insertOneRoute"]>>;
 export type CreateRouteResult = CreateValidatedRouteResult;
-export type ReplaceRouteOptions = RouteReplaceOptions;
-export type CreateTagOptions = TagInsertOptions;
+export type CreatePlannedRouteOptions = Omit<PrepareRouteOptions, "request"> & {
+    attempt: MultiCreateAttempt;
+};
+export type ReplaceRouteOptions = RouteReplaceOptions & {
+    availability?: RPRoutesAvailability;
+    expected?: Route;
+    before_request?: () => void;
+};
+export type RouteMutationOptions = {
+    actor: RoutesActor;
+    expected: Route;
+    signal?: AbortSignal;
+    before_request?: () => void;
+};
+export type ReplacePlannedRouteOptions = RouteMutationOptions & {
+    in: InRoute;
+    days_ago: PrepareRouteOptions["days_ago"];
+};
+export type CreateTagOptions = TagInsertOptions & Pick<MultiCreateCheckpoint, "before_request" | "on_created">;
 export type ReplaceTagOptions = TagReplaceOptions;
 export type SearchTagsOptions = OwnerSearchOptions;
 export type SearchTagsPage = SearchPage<Tag>;
-export type CreateClientAvailabilityOptions = ClientAvailabilityInsertOptions;
-export type ReplaceClientAvailabilityOptions = ClientAvailabilityReplaceOptions;
-export type CreateTrackingOptions = TrackingInsertOptions;
-export type ReplaceTrackingOptions = TrackingReplaceOptions;
-export type CreateRouteTeamOptions = RouteTeamInsertOptions;
+export type CreateClientAvailabilityOptions = ClientAvailabilityInsertOptions & Pick<MultiCreateCheckpoint, "before_request" | "on_created">;
+export type ReplaceClientAvailabilityOptions = ClientAvailabilityReplaceOptions & Pick<MultiCreateCheckpoint, "before_request">;
+export type CreateTrackingOptions = TrackingInsertOptions & Pick<MultiCreateCheckpoint, "before_request" | "on_created">;
+export type ReplaceTrackingOptions = TrackingReplaceOptions & Pick<MultiCreateCheckpoint, "before_request">;
+export type CreateRouteTeamOptions = RouteTeamInsertOptions & Pick<MultiCreateCheckpoint, "before_request" | "on_created">;
 export type ReplaceRouteTeamOptions = RouteTeamReplaceOptions;
 export type SearchRouteTeamsOptions = OwnerSearchOptions;
 export type SearchRouteTeamsPage = SearchPage<RouteTeam>;
@@ -36,9 +53,13 @@ export type RoutesFXOptions = {
     routes: RoutesOperator;
 };
 export interface RoutesFXOperator {
+    readonly workspace: RoutesWorkspace;
     createRoute(opts: CreateRouteOptions): Promise<Route>;
+    createPlannedRoute(opts: CreatePlannedRouteOptions): Promise<Route>;
     createValidatedRoute(opts: CreateRouteOptions): Promise<CreateValidatedRouteResult>;
     replaceRoute(opts: ReplaceRouteOptions): Promise<Route>;
+    replacePlannedRoute(opts: ReplacePlannedRouteOptions): Promise<Route>;
+    deletePlannedRoute(opts: RouteMutationOptions): Promise<void>;
     createTag(opts: CreateTagOptions): Promise<Tag>;
     replaceTag(opts: ReplaceTagOptions): Promise<Tag>;
     searchTags(opts: SearchTagsOptions): Promise<SearchTagsPage>;
@@ -52,10 +73,18 @@ export interface RoutesFXOperator {
 }
 export declare class RoutesFX implements RoutesFXOperator {
     private routes;
+    private routeMutationPending;
+    readonly workspace: RoutesWorkspace;
     constructor(opts: RoutesFXOptions);
     createRoute(opts: CreateRouteOptions): Promise<Route>;
+    createPlannedRoute(opts: CreatePlannedRouteOptions): Promise<Route>;
     createValidatedRoute(opts: CreateRouteOptions): Promise<CreateValidatedRouteResult>;
     replaceRoute(opts: ReplaceRouteOptions): Promise<Route>;
+    replacePlannedRoute(opts: ReplacePlannedRouteOptions): Promise<Route>;
+    deletePlannedRoute(opts: RouteMutationOptions): Promise<void>;
+    private checkedRoute;
+    private requireCurrentRoute;
+    private withRouteMutation;
     createTag(opts: CreateTagOptions): Promise<Tag>;
     replaceTag(opts: ReplaceTagOptions): Promise<Tag>;
     searchTags(opts: SearchTagsOptions): Promise<SearchTagsPage>;

package/dist/src/routes/routes.js

@@ -4,11 +4,12 @@
 // not use this file except in compliance with the License. You may obtain
 // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
 import { errResolveFailed, errValidation } from "../core/err.js";
+import { RoutesWorkspace, routeCanManage, routeCanPlan, } from "./workspace.js";
+import { RoutePreparationBlocked, RouteMutationBlock, routePlanChanged, } from "./planning.js";
+import { PreActionBlocked } from "../core/pre-action.js";
+import { normalizedTagInput, routeInput, validateClientAvailabilityInput, validateRouteInput, validateRouteTeamInput, validateTrackingInput, } from "./validation.js";
 import { requiredOperationID } from "../core/id.js";
 import { runOwnerSearch, } from "../core/search.js";
-const maxHour = 23;
-const maxMinute = 59;
-const maxMinuteOfDay = 1440;
 const resourceRoute = "route";
 const resourceTag = "tag";
 const resourceClientAvailability = "client_availability";
@@ -16,6 +17,7 @@ const resourceTracking = "tracking";
 const resourceRouteTeam = "route_team";
 const msgCreatedRouteIDMissing = "Created route response did not contain an ID.";
 const msgRouteMissing = "Route could not be resolved after the mutation.";
+const msgRouteOwner = "This route does not belong to the active employer.";
 const msgCreatedTagIDMissing = "Created tag response did not contain an ID.";
 const msgTagMissing = "Tag could not be resolved after the mutation.";
 const msgCreatedClientAvailabilityIDMissing = "Created client availability response did not contain an ID.";
@@ -24,42 +26,177 @@ const msgCreatedTrackingIDMissing = "Created tracking response did not contain a
 const msgTrackingMissing = "Tracking could not be resolved after the mutation.";
 const msgCreatedRouteTeamIDMissing = "Created route team response did not contain an ID.";
 const msgRouteTeamMissing = "Route team could not be resolved after the mutation.";
-const msgGlobalWindowSameDay = "The global route window must stay within one calendar day.";
-const msgGlobalWindowInvalid = "The global route window is invalid.";
-const msgEmployeeDuplicate = "An employee cannot be selected in more than one vehicle.";
-const msgEmployeeUnavailable = "A selected employee is not available for this route.";
-const msgLocationDuplicate = "A location cannot be selected more than once.";
-const msgLocationUnavailable = "A selected location is not available for this route.";
-const msgDestinationWindowInvalid = "A destination time window is invalid.";
-const msgDestinationWindowOutsideGlobal = "A destination time window must stay within the global route window.";
 export class RoutesFX {
     routes;
+    routeMutationPending = false;
+    workspace;
     constructor(opts) {
         this.routes = opts.routes;
+        this.workspace = new RoutesWorkspace(opts.routes);
     }
     async createRoute(opts) {
         const out = await this.createValidatedRoute(opts);
         const id = requiredOperationID(out, msgCreatedRouteIDMissing);
-        return await this.findRoute(id);
+        return await this.findRoute(id, opts.signal);
     }
-    async createValidatedRoute(opts) {
-        validateRoute(opts.in, opts.availability);
-        return await this.routes.insertOneRoute({
+    // Recheck availability immediately before each write. An acknowledged ID
+    // resumes only the read, so a failed follow-up GET cannot repeat optimization.
+    async createPlannedRoute(opts) {
+        const { attempt, actor } = opts;
+        if (!routeCanPlan(actor))
+            throw errValidation({ msg: msgRouteOwner });
+        if (attempt.created_id) {
+            const route = await this.findRoute(attempt.created_id, attempt.signal);
+            if (!routeCanManage(actor, route))
+                throw errValidation({ msg: msgRouteOwner });
+            return route;
+        }
+        const prepared = await this.workspace
+            .prepareRoute({
+            actor,
             in: opts.in,
+            days_ago: opts.days_ago,
+            request: { signal: attempt.signal },
+        })
+            .catch((error) => {
+            // No creation was attempted. Keep the draft editable in the shared queue.
+            throw new RoutePreparationBlocked(error);
+        });
+        return this.createRoute({
+            in: prepared.in,
+            availability: prepared.availability,
+            signal: attempt.signal,
+            idempotency_key: attempt.idempotency_key,
+            before_request: attempt.before_request,
+            on_created: attempt.on_created,
+        });
+    }
+    async createValidatedRoute(opts) {
+        const input = routeInput(opts.in);
+        validateRouteInput(input, opts.availability);
+        opts.before_request?.();
+        const out = await this.routes.insertOneRoute({
+            in: input,
+            signal: opts.signal,
+            idempotency_key: opts.idempotency_key,
         });
+        opts.on_created?.(requiredOperationID(out, msgCreatedRouteIDMissing));
+        return out;
     }
     async replaceRoute(opts) {
-        await this.routes.replaceOneRoute(opts);
-        return await this.findRoute(opts.id);
+        const current = await this.findRoute(opts.id, opts.signal);
+        if (opts.expected)
+            this.requireCurrentRoute(current, opts.expected);
+        const input = routeInput({ ...current, ...opts.in });
+        validateRouteInput(input, opts.availability, opts.id);
+        // Recompute changed plans, but do not invalidate vehicle/tracking IDs for
+        // an unchanged save. An explicit override still requests reoptimization.
+        const override_itinerary = routePlanChanged(current, input);
+        if (!override_itinerary)
+            return current;
+        opts.before_request?.();
+        await this.routes.replaceOneRoute({
+            id: opts.id,
+            signal: opts.signal,
+            in: {
+                ...opts.in,
+                ...(opts.in.from !== undefined ? { from: input.from } : {}),
+                ...(opts.in.to !== undefined ? { to: input.to } : {}),
+                ...(opts.in.vehicles !== undefined ? { vehicles: input.vehicles } : {}),
+                ...(opts.in.destinations !== undefined
+                    ? { destinations: input.destinations }
+                    : {}),
+                ...(opts.in.start_place_id !== undefined
+                    ? { start_place_id: input.start_place_id }
+                    : {}),
+                override_itinerary,
+            },
+        });
+        return await this.findRoute(opts.id, opts.signal);
+    }
+    async replacePlannedRoute(opts) {
+        return this.withRouteMutation(async () => {
+            const current = await this.checkedRoute(opts);
+            const input = routeInput(opts.in);
+            validateRouteInput(input);
+            if (!routePlanChanged(current, input))
+                return current;
+            const availability = await this.workspace.availability({
+                actor: opts.actor,
+                employee_ids: input.vehicles.flatMap((vehicle) => vehicle.employee_ids),
+                date: input.from,
+                days_ago: opts.days_ago,
+                request: { signal: opts.signal },
+            });
+            // Retain this route's own assignments, but never another route's.
+            validateRouteInput(input, availability, current.id);
+            const result = await this.replaceRoute({
+                id: current.id,
+                in: input,
+                expected: current,
+                availability,
+                signal: opts.signal,
+                before_request: opts.before_request,
+            });
+            if (result.override_itinerary ||
+                routePlanChanged(result, {
+                    ...input,
+                    override_itinerary: false,
+                }))
+                throw new PreActionBlocked(RouteMutationBlock.Unconfirmed);
+            return result;
+        });
+    }
+    async deletePlannedRoute(opts) {
+        return this.withRouteMutation(async () => {
+            const current = await this.checkedRoute(opts);
+            opts.signal?.throwIfAborted();
+            opts.before_request?.();
+            await this.routes.deleteOneRoute({ id: current.id });
+        });
+    }
+    async checkedRoute(opts) {
+        if (!routeCanManage(opts.actor, opts.expected))
+            throw errValidation({ msg: msgRouteOwner });
+        const current = await this.findRoute(opts.expected.id, opts.signal);
+        if (!routeCanManage(opts.actor, current))
+            throw errValidation({ msg: msgRouteOwner });
+        this.requireCurrentRoute(current, opts.expected);
+        return current;
+    }
+    requireCurrentRoute(current, expected) {
+        if (current.id !== expected.id ||
+            current.updated_at !== expected.updated_at)
+            throw new PreActionBlocked(RouteMutationBlock.Changed);
+    }
+    async withRouteMutation(fn) {
+        if (this.routeMutationPending)
+            throw new PreActionBlocked(RouteMutationBlock.Busy);
+        this.routeMutationPending = true;
+        try {
+            return await fn();
+        }
+        finally {
+            this.routeMutationPending = false;
+        }
     }
     async createTag(opts) {
-        const out = await this.routes.insertOneTag(opts);
+        const { on_created, before_request, ...request } = opts;
+        const input = normalizedTagInput(opts.in);
+        before_request?.();
+        const out = await this.routes.insertOneTag({
+            ...request,
+            in: input,
+        });
         const id = requiredOperationID(out, msgCreatedTagIDMissing);
-        return await this.findTag(id);
+        on_created?.(id);
+        return await this.findTag(id, opts.signal);
     }
     async replaceTag(opts) {
-        await this.routes.replaceOneTag(opts);
-        return await this.findTag(opts.id);
+        const current = await this.findTag(opts.id, opts.signal);
+        const input = normalizedTagInput({ ...current, ...opts.in });
+        await this.routes.replaceOneTag({ ...opts, in: input });
+        return await this.findTag(opts.id, opts.signal);
     }
     async searchTags(opts) {
         return await runOwnerSearch({
@@ -68,31 +205,53 @@ export class RoutesFX {
         });
     }
     async createClientAvailability(opts) {
-        const out = await this.routes.insertOneClientAvailability(opts);
+        validateClientAvailabilityInput(opts.in);
+        const { before_request, on_created, ...request } = opts;
+        before_request?.();
+        const out = await this.routes.insertOneClientAvailability(request);
         const id = requiredOperationID(out, msgCreatedClientAvailabilityIDMissing);
-        return await this.findClientAvailability(id);
+        on_created?.(id);
+        return await this.findClientAvailability(id, opts.signal);
     }
     async replaceClientAvailability(opts) {
-        await this.routes.replaceOneClientAvailability(opts);
-        return await this.findClientAvailability(opts.id);
+        const current = await this.findClientAvailability(opts.id, opts.signal);
+        validateClientAvailabilityInput({ ...current, ...opts.in });
+        const { before_request, ...request } = opts;
+        before_request?.();
+        await this.routes.replaceOneClientAvailability(request);
+        return await this.findClientAvailability(opts.id, opts.signal);
     }
     async createTracking(opts) {
-        const out = await this.routes.insertOneTracking(opts);
+        validateTrackingInput(opts.in);
+        const { before_request, on_created, ...request } = opts;
+        before_request?.();
+        const out = await this.routes.insertOneTracking(request);
         const id = requiredOperationID(out, msgCreatedTrackingIDMissing);
-        return await this.findTracking(id);
+        on_created?.(id);
+        return await this.findTracking(id, opts.signal);
     }
     async replaceTracking(opts) {
-        await this.routes.replaceOneTracking(opts);
-        return await this.findTracking(opts.id);
+        const current = await this.findTracking(opts.id, opts.signal);
+        validateTrackingInput({ ...current, ...opts.in }, current);
+        const { before_request, ...request } = opts;
+        before_request?.();
+        await this.routes.replaceOneTracking(request);
+        return await this.findTracking(opts.id, opts.signal);
     }
     async createRouteTeam(opts) {
-        const out = await this.routes.insertOneRouteTeam(opts);
+        const { on_created, before_request, ...request } = opts;
+        validateRouteTeamInput(opts.in);
+        before_request?.();
+        const out = await this.routes.insertOneRouteTeam(request);
         const id = requiredOperationID(out, msgCreatedRouteTeamIDMissing);
-        return await this.findRouteTeam(id);
+        on_created?.(id);
+        return await this.findRouteTeam(id, opts.signal);
     }
     async replaceRouteTeam(opts) {
+        const current = await this.findRouteTeam(opts.id, opts.signal);
+        validateRouteTeamInput({ ...current, ...opts.in });
         await this.routes.replaceOneRouteTeam(opts);
-        return await this.findRouteTeam(opts.id);
+        return await this.findRouteTeam(opts.id, opts.signal);
     }
     async searchRouteTeams(opts) {
         return await runOwnerSearch({
@@ -100,9 +259,10 @@ export class RoutesFX {
             search: (searchOpts) => this.routes.searchManyRouteTeams(searchOpts),
         });
     }
-    async findRoute(id) {
+    async findRoute(id, signal) {
         const out = await this.routes.findOneRoute({
             id,
+            signal,
         });
         const route = out.value;
         if (route === undefined) {
@@ -113,9 +273,10 @@ export class RoutesFX {
         }
         return route;
     }
-    async findTag(id) {
+    async findTag(id, signal) {
         const out = await this.routes.findOneTag({
             id,
+            signal,
         });
         const tag = out.value;
         if (tag === undefined) {
@@ -126,9 +287,10 @@ export class RoutesFX {
         }
         return tag;
     }
-    async findClientAvailability(id) {
+    async findClientAvailability(id, signal) {
         const out = await this.routes.findOneClientAvailability({
             id,
+            signal,
         });
         const client_availability = out.value;
         if (client_availability === undefined) {
@@ -139,9 +301,10 @@ export class RoutesFX {
         }
         return client_availability;
     }
-    async findTracking(id) {
+    async findTracking(id, signal) {
         const out = await this.routes.findOneTracking({
             id,
+            signal,
         });
         const tracking = out.value;
         if (tracking === undefined) {
@@ -152,9 +315,10 @@ export class RoutesFX {
         }
         return tracking;
     }
-    async findRouteTeam(id) {
+    async findRouteTeam(id, signal) {
         const out = await this.routes.findOneRouteTeam({
             id,
+            signal,
         });
         const route_team = out.value;
         if (route_team === undefined) {
@@ -169,105 +333,3 @@ export class RoutesFX {
 export function newRoutesFX(opts) {
     return new RoutesFX(opts);
 }
-function validateRoute(input, availability) {
-    if (!sameDay(input.from, input.to)) {
-        throw errValidation({
-            field: "to",
-            msg: msgGlobalWindowSameDay,
-        });
-    }
-    const fromMinute = minuteOfDay(input.from);
-    const toMinute = minuteOfDay(input.to);
-    if (fromMinute === undefined ||
-        toMinute === undefined ||
-        fromMinute >= toMinute) {
-        throw errValidation({
-            field: "to",
-            msg: msgGlobalWindowInvalid,
-        });
-    }
-    validateVehicles(input, availability);
-    validateDestinations(input, availability, fromMinute, toMinute);
-}
-function validateVehicles(input, availability) {
-    const availableEmployeeIDs = new Set(availability.availables.employees.map((id) => id.trim()));
-    const employeeIDs = new Set();
-    for (const vehicle of input.vehicles) {
-        for (const rawEmployeeID of vehicle.employee_ids) {
-            const employeeID = rawEmployeeID.trim();
-            if (employeeID === "") {
-                continue;
-            }
-            if (employeeIDs.has(employeeID)) {
-                throw errValidation({
-                    field: "vehicles",
-                    msg: msgEmployeeDuplicate,
-                });
-            }
-            if (!availableEmployeeIDs.has(employeeID)) {
-                throw errValidation({
-                    field: "vehicles",
-                    msg: msgEmployeeUnavailable,
-                });
-            }
-            employeeIDs.add(employeeID);
-        }
-    }
-}
-function validateDestinations(input, availability, fromMinute, toMinute) {
-    const availableLocationIDs = new Set(availability.availables.locations.map((id) => id.trim()));
-    const locationIDs = new Set();
-    for (const destination of input.destinations) {
-        const locationID = destination.location_id.trim();
-        if (locationID !== "") {
-            if (locationIDs.has(locationID)) {
-                throw errValidation({
-                    field: "destinations",
-                    msg: msgLocationDuplicate,
-                });
-            }
-            if (!availableLocationIDs.has(locationID)) {
-                throw errValidation({
-                    field: "destinations",
-                    msg: msgLocationUnavailable,
-                });
-            }
-            locationIDs.add(locationID);
-        }
-        if (!destination.use_time_window) {
-            continue;
-        }
-        const start = destination.time_window_start_hour_in_minutes;
-        const end = destination.time_window_end_hour_in_minutes;
-        if (!Number.isInteger(start) ||
-            !Number.isInteger(end) ||
-            start < 0 ||
-            end > maxMinuteOfDay ||
-            start >= end) {
-            throw errValidation({
-                field: "destinations",
-                msg: msgDestinationWindowInvalid,
-            });
-        }
-        if (start < fromMinute || end > toMinute) {
-            throw errValidation({
-                field: "destinations",
-                msg: msgDestinationWindowOutsideGlobal,
-            });
-        }
-    }
-}
-function sameDay(a, b) {
-    return a.y === b.y && a.m === b.m && a.d === b.d;
-}
-function minuteOfDay(v) {
-    if (!Number.isInteger(v.h) ||
-        !Number.isInteger(v.min) ||
-        v.h < 0 ||
-        v.h > maxHour ||
-        v.min < 0 ||
-        v.min > maxMinute) {
-        return undefined;
-    }
-    return v.h * 60 + v.min;
-}