@fabriktor/fx 0.0.139 → 0.0.141

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

@@ -0,0 +1,45 @@
+import type { BillableOperator, JobsOperator, UsersOperator } from "@fabriktor/client";
+import type { Address, InRoute, Location, Route, User, Warehouse } from "@fabriktor/schema";
+export declare const RouteDepartureSource: {
+    readonly Company: "company";
+    readonly Warehouse: "warehouse";
+    readonly SavedRoute: "saved_route";
+};
+export type RouteDepartureReference = {
+    source: typeof RouteDepartureSource.Company;
+} | {
+    source: typeof RouteDepartureSource.Warehouse;
+    warehouse_id: string;
+} | {
+    source: typeof RouteDepartureSource.SavedRoute;
+    route_id: string;
+};
+export type RouteDeparture = {
+    reference: RouteDepartureReference;
+    address: Address;
+    name: string;
+};
+export type RoutePlanningReaders = {
+    users: Pick<UsersOperator, "findOneUser">;
+    billable: Pick<BillableOperator, "findOneWarehouse">;
+    jobs: Pick<JobsOperator, "findOneLocation">;
+};
+export declare const RoutePlanningBlock: {
+    readonly Departure: "route_departure_invalid";
+    readonly DepartureChanged: "route_departure_changed";
+    readonly DestinationTimezone: "route_destination_timezone";
+    readonly DestinationChanged: "route_destination_changed";
+};
+export declare function companyRouteDeparture(user: User): RouteDeparture;
+export declare function warehouseRouteDeparture(warehouse: Warehouse, owner_id: string): RouteDeparture;
+export declare function loadRouteDeparture(readers: RoutePlanningReaders, owner_id: string, reference: Exclude<RouteDepartureReference, {
+    source: typeof RouteDepartureSource.SavedRoute;
+}>, signal?: AbortSignal): Promise<RouteDeparture>;
+export declare function validateRoutePlanLocation(location: Location, owner_id: string, timezone: string): void;
+export declare function validateRoutePlanAddresses(readers: RoutePlanningReaders, opts: {
+    owner_id: string;
+    input: InRoute;
+    departure: RouteDepartureReference;
+    current?: Route;
+    signal?: AbortSignal;
+}): Promise<void>;

package/dist/src/routes/departure.js

@@ -0,0 +1,98 @@
+import { UserTypeEmployer } from "@fabriktor/schema";
+import { addressTimezone } from "../core/address.js";
+import { resolvedID } from "../core/id.js";
+import { PreActionBlocked } from "../core/pre-action.js";
+export const RouteDepartureSource = {
+    Company: "company",
+    Warehouse: "warehouse",
+    SavedRoute: "saved_route",
+};
+export const RoutePlanningBlock = {
+    Departure: "route_departure_invalid",
+    DepartureChanged: "route_departure_changed",
+    DestinationTimezone: "route_destination_timezone",
+    DestinationChanged: "route_destination_changed",
+};
+export function companyRouteDeparture(user) {
+    if (user.account_identity !== UserTypeEmployer ||
+        !user.place_id.trim() ||
+        !addressTimezone(user))
+        throw new PreActionBlocked(RoutePlanningBlock.Departure);
+    return {
+        reference: { source: RouteDepartureSource.Company },
+        address: user,
+        name: "",
+    };
+}
+export function warehouseRouteDeparture(warehouse, owner_id) {
+    if (warehouse.owner_id !== owner_id ||
+        warehouse.is_archived ||
+        !warehouse.place_id.trim() ||
+        !addressTimezone(warehouse))
+        throw new PreActionBlocked(RoutePlanningBlock.Departure);
+    return {
+        reference: {
+            source: RouteDepartureSource.Warehouse,
+            warehouse_id: warehouse.id,
+        },
+        address: warehouse,
+        name: warehouse.name,
+    };
+}
+export async function loadRouteDeparture(readers, owner_id, reference, signal) {
+    if (reference.source === RouteDepartureSource.Warehouse) {
+        const warehouse = (await readers.billable.findOneWarehouse({
+            id: reference.warehouse_id,
+            signal,
+        })).value;
+        if (warehouse?.id === reference.warehouse_id)
+            return warehouseRouteDeparture(warehouse, owner_id);
+    }
+    else {
+        const user = (await readers.users.findOneUser({ id: owner_id, signal }))
+            .value;
+        if (user?.id === owner_id)
+            return companyRouteDeparture(user);
+    }
+    throw new PreActionBlocked(RoutePlanningBlock.Departure);
+}
+export function validateRoutePlanLocation(location, owner_id, timezone) {
+    if (location.owner_id !== owner_id ||
+        location.is_archived ||
+        !location.place_id.trim() ||
+        !resolvedID(location.client_id))
+        throw new PreActionBlocked(RoutePlanningBlock.DestinationChanged);
+    if (addressTimezone(location) !== timezone)
+        throw new PreActionBlocked(RoutePlanningBlock.DestinationTimezone);
+}
+// Re-read saved operational addresses before optimization. A queued draft must
+// not submit stale location ownership, Place IDs or address timezones.
+export async function validateRoutePlanAddresses(readers, opts) {
+    const { input, departure, current, signal } = opts;
+    if (departure.source === RouteDepartureSource.SavedRoute) {
+        if (!current ||
+            current.id !== departure.route_id ||
+            current.owner_id !== opts.owner_id ||
+            current.start_place_id !== input.start_place_id ||
+            current.timezone !== input.timezone)
+            throw new PreActionBlocked(RoutePlanningBlock.DepartureChanged);
+    }
+    else {
+        const saved = await loadRouteDeparture(readers, opts.owner_id, departure, signal);
+        if (saved.address.place_id !== input.start_place_id ||
+            addressTimezone(saved.address) !== input.timezone)
+            throw new PreActionBlocked(RoutePlanningBlock.DepartureChanged);
+    }
+    for (const destination of input.destinations) {
+        const location = (await readers.jobs.findOneLocation({
+            id: destination.location_id,
+            signal,
+        })).value;
+        if (!location ||
+            location.id !== destination.location_id ||
+            location.client_id !== destination.client_id ||
+            location.place_id !== destination.place_id)
+            throw new PreActionBlocked(RoutePlanningBlock.DestinationChanged);
+        validateRoutePlanLocation(location, opts.owner_id, input.timezone);
+    }
+}

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

@@ -0,0 +1,34 @@
+import type { ClientAvailability, InDate, InRoute, Location, PrefCompany, RPRoutesAvailability, Route } from "@fabriktor/schema";
+import { PreActionBlocked } from "../core/pre-action.js";
+declare const routePreparationBlocked = "route_preparation";
+export declare const RouteMutationBlock: {
+    readonly Busy: "route_mutation_busy";
+    readonly Changed: "route_mutation_changed";
+    readonly Unconfirmed: "route_mutation_unconfirmed";
+};
+export declare function routePlanChanged(current: Route, input: InRoute): boolean;
+export declare class RoutePreparationBlocked extends PreActionBlocked<typeof routePreparationBlocked> {
+    readonly cause: unknown;
+    constructor(cause: unknown);
+}
+export declare const routePlanningDefaults: {
+    readonly days_ago: 0;
+    readonly duration_in_minutes: 0;
+    readonly consider_traffic: false;
+    readonly start_early: false;
+    readonly override_itinerary: false;
+};
+export declare function newRoutePlan(opts: {
+    day: InDate;
+    company: Pick<PrefCompany, "work_day_start_hour" | "work_day_end_hour">;
+    start_place_id: string;
+}): InRoute;
+export declare function routeDestination(location: Location, owner_id: string, timezone: string): InRoute["destinations"][number];
+export declare function validateRouteEmployees(ids: readonly string[], allowed: readonly string[], occupied?: readonly string[]): void;
+export type RouteAvailabilityWindow = {
+    availability: ClientAvailability;
+    start: number;
+    end: number;
+};
+export declare function routeAvailabilityWindows(input: Pick<InRoute, "from" | "to" | "timezone">, availability: RPRoutesAvailability, location_id: string, client_id: string): RouteAvailabilityWindow[];
+export {};

package/dist/src/routes/planning.js

@@ -0,0 +1,94 @@
+import { isValidInputDate, minutesOfDay, sameCalendarDay, } from "../core/date.js";
+import { errValidation } from "../core/err.js";
+import { normalizeIDs } from "../core/id.js";
+import { routeInput, validateRouteTimeWindow } from "./validation.js";
+import { validateRoutePlanLocation } from "./departure.js";
+import { PreActionBlocked } from "../core/pre-action.js";
+const routePreparationBlocked = "route_preparation";
+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, timezone) {
+    validateRoutePlanLocation(location, owner_id, timezone);
+    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,8 @@
+import { type RouteDepartureReference, type RoutePlanningReaders } from "./departure.js";
 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,34 +14,55 @@ 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;
+    departure: RouteDepartureReference;
+};
+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"];
+    departure: RouteDepartureReference;
+};
+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>;
-export type RoutesFXOptions = {
+export type RoutesFXOptions = RoutePlanningReaders & {
     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>;
@@ -51,11 +75,20 @@ export interface RoutesFXOperator {
     searchRouteTeams(opts: SearchRouteTeamsOptions): Promise<SearchRouteTeamsPage>;
 }
 export declare class RoutesFX implements RoutesFXOperator {
+    private readonly opts;
     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>;