@openinc/parse-server-opendash 4.1.8 → 4.2.1

package/dist/features/openservice/serviceSchedules/calendarSync/service/ServiceCalendarSyncPoller.js

@@ -0,0 +1,248 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceCalendarSyncPoller = exports.CALENDAR_SYNC_CONTEXT_FLAG = void 0;
+const crypto_1 = require("crypto");
+const node_1 = __importDefault(require("parse/node"));
+const CalendarManager_js_1 = require("../../../schedules/calendarSync/service/CalendarManager.js");
+const index_js_1 = require("../../../../../types/index.js");
+const eventToPlan_js_1 = require("../functions/eventToPlan.js");
+const serviceCalendarMeta_js_1 = require("./serviceCalendarMeta.js");
+/**
+ * Marker on a save that came from the calendar.
+ *
+ * The outbound side (`syncPlanToCalendar`, called from the `Service_Schedule`
+ * afterSave hook) checks it and stays quiet — otherwise every inbound change
+ * would be written straight back to Outlook, produce a new `changeKey`, come
+ * back through the delta feed as a foreign change, and loop forever. The stored
+ * `changeKey` is the second line of defence; this is the first, and unlike v1's
+ * `!master` check it does not disable outbound sync for every other
+ * master-key writer (the scheduler pausing a plan, a migration, a script).
+ */
+exports.CALENDAR_SYNC_CONTEXT_FLAG = "fromCalendarSync";
+/**
+ * Pulls Outlook changes into open.SERVICE **v2** maintenance plans.
+ *
+ * One poller per configured connection, driven by the Graph *delta* feed: the
+ * first call reads the whole calendar, each later call only what changed, and
+ * the cursor lives in the Config row so a restart resumes instead of
+ * re-importing. The v1 poller does the same for `Maintenance_Schedule` from the
+ * same connection — the two keep separate cursors (`delta_link` vs
+ * `delta_link_v2`) so neither consumes the other's changes.
+ */
+class ServiceCalendarSyncPoller {
+    timer = null;
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    get values() {
+        return JSON.parse(this.config.get("value"));
+    }
+    get manager() {
+        const values = this.values;
+        return new CalendarManager_js_1.CalendarManager({
+            tenantId: values.tenant_id,
+            clientID: values.client_id,
+            clientSecret: values.client_secret,
+            userMail: values.user_email,
+        });
+    }
+    start(intervalMs = 5 * 60 * 1000) {
+        const valid = this.manager.isValid;
+        if (valid !== true) {
+            console.error(`[ServiceCalendarSync] Not started — invalid configuration: ${valid}`);
+            return this;
+        }
+        this.poll().catch(console.error);
+        this.timer = setInterval(() => this.poll().catch(console.error), intervalMs);
+        return this;
+    }
+    stop() {
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = null;
+    }
+    async poll() {
+        const result = await this.manager.fetchDelta(await this.loadDeltaLink());
+        if (!result) {
+            console.error("[ServiceCalendarSync] Could not fetch the calendar delta");
+            return;
+        }
+        for (const event of result.events) {
+            try {
+                await this.processEvent(event);
+            }
+            catch (error) {
+                // One unusable event must not cost us the whole batch — and not the
+                // delta cursor either, or it would be retried forever.
+                console.error("[ServiceCalendarSync] Event could not be processed:", event.id, error);
+            }
+        }
+        await this.saveDeltaLink(result.deltaLink);
+    }
+    async processEvent(event) {
+        if (event["@removed"]) {
+            await this.handleRemoved(event.id);
+            return;
+        }
+        // An "exception" is a single moved or edited occurrence of a series. The
+        // plan's own `cadenceExceptions` could hold that, but Graph does not tell
+        // us *which* occurrence was moved in a form we can map back reliably — and
+        // a wrong exception silently moves a maintenance date. The series master
+        // carries the recurrence; exceptions are left to Outlook.
+        if (event.type === "exception")
+            return;
+        const meta = await (0, serviceCalendarMeta_js_1.findMetaForEvent)(event.id);
+        if (!meta) {
+            // Delta payloads are partial — fetch the whole event before creating.
+            const full = await this.manager.fetchEvent(event.id);
+            if (full)
+                await this.createPlan(full);
+            return;
+        }
+        if (event.changeKey &&
+            (0, serviceCalendarMeta_js_1.metaValues)(meta)?.microsoftCalendarChangeKey === event.changeKey) {
+            return; // Our own write, echoed back by the delta feed.
+        }
+        await this.updatePlan(meta, event);
+    }
+    async createPlan(event) {
+        const fields = (0, eventToPlan_js_1.eventToPlanFields)(event);
+        if (!fields) {
+            console.warn(`[ServiceCalendarSync] Event ${event.id} has no usable start — skipped`);
+            return;
+        }
+        const tenant = this.config.get("tenant");
+        const equipment = await this.resolveEquipment(fields.equipmentName, tenant);
+        const plan = new index_js_1.Service_Schedule();
+        plan.set("title", fields.title);
+        plan.set("active", true);
+        plan.set("tenant", tenant);
+        plan.set("cadence", fields.cadence);
+        if (equipment)
+            plan.set("equipment", equipment);
+        // A plan needs at least one step to be executable. The event's note becomes
+        // its description, so what someone wrote in Outlook is not lost — the
+        // checklist proper is then built in the plan editor.
+        plan.set("steps", [
+            {
+                id: (0, crypto_1.randomUUID)(),
+                order: 0,
+                title: fields.title,
+                ...(fields.description ? { description: fields.description } : {}),
+                required: false,
+            },
+        ]);
+        plan.set("notifications", (0, eventToPlan_js_1.mergeReminderRule)([], fields.notification));
+        await plan.save(null, {
+            useMasterKey: true,
+            context: { [exports.CALENDAR_SYNC_CONTEXT_FLAG]: true },
+        });
+        await (0, serviceCalendarMeta_js_1.saveMeta)(plan.id, event.id, event.changeKey, tenant, event);
+        console.log(`[ServiceCalendarSync] Created plan ${plan.id} from event ${event.id}` +
+            (equipment ? ` (machine ${equipment.id})` : " (no machine)"));
+    }
+    async updatePlan(meta, event) {
+        const planId = meta.get("entryObjectId");
+        if (!planId)
+            return;
+        // Delta payloads are partial: without the full event, an unchanged subject
+        // would arrive as `undefined` and wipe the plan's title.
+        const full = (await this.manager.fetchEvent(event.id)) ?? event;
+        const fields = (0, eventToPlan_js_1.eventToPlanFields)(full);
+        if (!fields)
+            return;
+        const plan = await new node_1.default.Query(index_js_1.Service_Schedule)
+            .include("equipment")
+            .get(planId, { useMasterKey: true });
+        plan.set("title", fields.title);
+        plan.set("cadence", fields.cadence);
+        plan.set("notifications", (0, eventToPlan_js_1.mergeReminderRule)(plan.get("notifications"), fields.notification));
+        // The machine only changes if the subject actually names a different one —
+        // a subject without the prefix leaves the existing assignment alone rather
+        // than falling back to the configured default and moving the plan.
+        if (fields.equipmentName) {
+            const equipment = await this.findEquipmentByLabel(fields.equipmentName, this.config.get("tenant"));
+            if (equipment)
+                plan.set("equipment", equipment);
+        }
+        await plan.save(null, {
+            useMasterKey: true,
+            context: { [exports.CALENDAR_SYNC_CONTEXT_FLAG]: true },
+        });
+        if (event.changeKey)
+            await (0, serviceCalendarMeta_js_1.updateChangeKey)(meta, event.changeKey, full);
+    }
+    /**
+     * A deleted appointment archives the plan — it never destroys it.
+     *
+     * Executions document that work happened; deleting the plan they point at
+     * would strand that history (the `beforeDelete` hook refuses it, too). The
+     * meta entry goes, so the same plan can be linked to a new event later.
+     */
+    async handleRemoved(eventId) {
+        const meta = await (0, serviceCalendarMeta_js_1.findMetaForEvent)(eventId);
+        if (!meta)
+            return;
+        const planId = meta.get("entryObjectId");
+        if (planId) {
+            try {
+                const plan = await new node_1.default.Query(index_js_1.Service_Schedule).get(planId, {
+                    useMasterKey: true,
+                });
+                plan.set("active", false);
+                plan.set("deletedAt", new Date());
+                await plan.save(null, {
+                    useMasterKey: true,
+                    context: { [exports.CALENDAR_SYNC_CONTEXT_FLAG]: true },
+                });
+            }
+            catch (error) {
+                console.error(`[ServiceCalendarSync] Could not archive plan ${planId} of deleted event ${eventId}:`, error);
+            }
+        }
+        await meta.destroy({ useMasterKey: true });
+    }
+    /** The machine named in the subject, else the configured fallback. */
+    async resolveEquipment(label, tenant) {
+        if (label) {
+            const found = await this.findEquipmentByLabel(label, tenant);
+            if (found)
+                return found;
+            console.warn(`[ServiceCalendarSync] No machine named "${label}" — falling back to the default`);
+        }
+        const defaultId = this.values.default_equipment_id;
+        if (!defaultId)
+            return undefined;
+        return ((await new node_1.default.Query(index_js_1.Service_Equipment)
+            .equalTo("objectId", defaultId)
+            .first({ useMasterKey: true })) ?? undefined);
+    }
+    async findEquipmentByLabel(label, tenant) {
+        const query = new node_1.default.Query(index_js_1.Service_Equipment).equalTo("label", label);
+        if (tenant)
+            query.equalTo("tenant", tenant);
+        query.notEqualTo("deleted", true);
+        return (await query.first({ useMasterKey: true })) ?? undefined;
+    }
+    /**
+     * The cursor is re-read from the Config row on every tick, and written back
+     * after it: the row is also the admin form's storage, so it can change
+     * underneath us.
+     */
+    async loadDeltaLink() {
+        this.config = await this.config.fetch({ useMasterKey: true });
+        return this.values.delta_link_v2;
+    }
+    async saveDeltaLink(link) {
+        this.config = await this.config.fetch({ useMasterKey: true });
+        const values = this.values;
+        values.delta_link_v2 = link;
+        this.config.set("value", JSON.stringify(values));
+        await this.config.save(null, { useMasterKey: true });
+    }
+}
+exports.ServiceCalendarSyncPoller = ServiceCalendarSyncPoller;

package/dist/features/openservice/serviceSchedules/calendarSync/service/serviceCalendarMeta.d.ts

@@ -0,0 +1,55 @@
+import type { MetaConfig } from "../../../../../types/custom/MetaField.js";
+import { Meta_Entry, Tenant } from "../../../../../types/index.js";
+import type { GraphEventResponse } from "../../../schedules/calendarSync/types/Event.js";
+/**
+ * Which calendar event belongs to which v2 maintenance plan.
+ *
+ * Same mechanism as v1 (a `Meta_Entry` per plan), but a **separate context**:
+ * one Outlook connection serves both generations, and a v1 entry pointing at a
+ * `Maintenance_Schedule` must never be mistaken for a v2 one pointing at an
+ * `OD3_Service_Schedule`. The stored `changeKey` is what keeps the two sides
+ * from echoing each other — see `ServiceCalendarSyncPoller`.
+ */
+export declare const SERVICE_CALENDAR_SYNC_CONTEXT: string;
+/**
+ * The last known state of the event, as far as the sync needs it.
+ *
+ * Kept so an outbound update can preserve what the user set in Outlook and this
+ * side has no field for — the event's times above all: a plan knows a due
+ * *date*, and writing that back must not turn someone's 9:00 appointment into
+ * an all-day block.
+ */
+export interface ServiceCalendarEventSnapshot {
+    id: string;
+    subject?: string;
+    start: {
+        dateTime: string;
+        timeZone: string;
+    };
+    end: {
+        dateTime: string;
+        timeZone: string;
+    };
+    isAllDay?: boolean;
+    isCancelled?: boolean;
+    recurrence?: GraphEventResponse["recurrence"];
+}
+export interface ServiceCalendarMetaValues {
+    microsoftCalendarEventId: string;
+    microsoftCalendarChangeKey?: string;
+    microsoftCalendarEvent?: ServiceCalendarEventSnapshot;
+}
+/** Shown by the meta plugin when the entry is inspected in the frontend. */
+export declare const ServiceCalendarMetaConfig: MetaConfig;
+export declare function findMetaForPlan(scheduleId: string): Promise<Meta_Entry | null>;
+export declare function findMetaForEvent(eventId: string): Promise<Meta_Entry | null>;
+export declare function saveMeta(scheduleId: string, eventId: string, changeKey?: string, tenant?: Tenant, event?: GraphEventResponse): Promise<Meta_Entry>;
+/**
+ * Remember the `changeKey` of the version we just wrote.
+ *
+ * This is the loop breaker: the delta feed will report our own write back to
+ * us, and the poller recognises it by this key. Losing it means one harmless
+ * extra round trip; writing the wrong one means an endless echo.
+ */
+export declare function updateChangeKey(entry: Meta_Entry, changeKey: string, event?: GraphEventResponse): Promise<void>;
+export declare function metaValues(entry: Meta_Entry): ServiceCalendarMetaValues | undefined;

package/dist/features/openservice/serviceSchedules/calendarSync/service/serviceCalendarMeta.js

@@ -0,0 +1,109 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceCalendarMetaConfig = exports.SERVICE_CALENDAR_SYNC_CONTEXT = void 0;
+exports.findMetaForPlan = findMetaForPlan;
+exports.findMetaForEvent = findMetaForEvent;
+exports.saveMeta = saveMeta;
+exports.updateChangeKey = updateChangeKey;
+exports.metaValues = metaValues;
+const node_1 = __importDefault(require("parse/node"));
+const index_js_1 = require("../../../../../types/index.js");
+/**
+ * Which calendar event belongs to which v2 maintenance plan.
+ *
+ * Same mechanism as v1 (a `Meta_Entry` per plan), but a **separate context**:
+ * one Outlook connection serves both generations, and a v1 entry pointing at a
+ * `Maintenance_Schedule` must never be mistaken for a v2 one pointing at an
+ * `OD3_Service_Schedule`. The stored `changeKey` is what keeps the two sides
+ * from echoing each other — see `ServiceCalendarSyncPoller`.
+ */
+exports.SERVICE_CALENDAR_SYNC_CONTEXT = JSON.stringify([
+    "service",
+    "schedule",
+    "sync",
+    "microsoft",
+]);
+/** Shown by the meta plugin when the entry is inspected in the frontend. */
+exports.ServiceCalendarMetaConfig = {
+    fields: [
+        {
+            name: "microsoftCalendarEventId",
+            type: "string",
+            label: "Microsoft Calendar Event ID",
+        },
+        {
+            name: "microsoftCalendarChangeKey",
+            type: "string",
+            label: "Microsoft Calendar Change Key",
+        },
+    ],
+};
+function toSnapshot(event) {
+    return {
+        id: event.id,
+        subject: event.subject,
+        start: event.start,
+        end: event.end,
+        isAllDay: event.isAllDay,
+        isCancelled: event.isCancelled,
+        recurrence: event.recurrence ?? undefined,
+    };
+}
+async function findMetaForPlan(scheduleId) {
+    return ((await new node_1.default.Query(index_js_1.Meta_Entry)
+        .equalTo("context", exports.SERVICE_CALENDAR_SYNC_CONTEXT)
+        .equalTo("entryClassName", index_js_1.Service_Schedule.className)
+        .equalTo("entryObjectId", scheduleId)
+        .first({ useMasterKey: true })) ?? null);
+}
+async function findMetaForEvent(eventId) {
+    return ((await new node_1.default.Query(index_js_1.Meta_Entry)
+        .equalTo("context", exports.SERVICE_CALENDAR_SYNC_CONTEXT)
+        .equalTo("entryClassName", index_js_1.Service_Schedule.className)
+        // Dot access into the `values` Object column — Mongo resolves it, the
+        // generated type only knows top-level columns.
+        // @ts-expect-error
+        .equalTo("values.microsoftCalendarEventId", eventId)
+        .first({ useMasterKey: true })) ?? null);
+}
+async function saveMeta(scheduleId, eventId, changeKey, tenant, event) {
+    let entry = await findMetaForPlan(scheduleId);
+    if (!entry) {
+        entry = new index_js_1.Meta_Entry();
+        entry.set("context", exports.SERVICE_CALENDAR_SYNC_CONTEXT);
+        entry.set("entryClassName", index_js_1.Service_Schedule.className);
+        entry.set("entryObjectId", scheduleId);
+        entry.set("tenant", tenant);
+        entry.set("config", {});
+    }
+    const values = {
+        microsoftCalendarEventId: eventId,
+    };
+    if (changeKey)
+        values.microsoftCalendarChangeKey = changeKey;
+    if (event)
+        values.microsoftCalendarEvent = toSnapshot(event);
+    entry.set("values", values);
+    return entry.save(null, { useMasterKey: true });
+}
+/**
+ * Remember the `changeKey` of the version we just wrote.
+ *
+ * This is the loop breaker: the delta feed will report our own write back to
+ * us, and the poller recognises it by this key. Losing it means one harmless
+ * extra round trip; writing the wrong one means an endless echo.
+ */
+async function updateChangeKey(entry, changeKey, event) {
+    entry.set("values", {
+        ...entry.get("values"),
+        microsoftCalendarChangeKey: changeKey,
+        ...(event ? { microsoftCalendarEvent: toSnapshot(event) } : {}),
+    });
+    await entry.save(null, { useMasterKey: true });
+}
+function metaValues(entry) {
+    return entry.get("values");
+}

package/dist/features/openservice/serviceSchedules/calendarSync/service/syncPlanToCalendar.d.ts

@@ -0,0 +1,26 @@
+import { CalendarManager } from "../../../schedules/calendarSync/service/CalendarManager.js";
+import { Service_Schedule, Tenant } from "../../../../../types/index.js";
+import type { ServiceSyncConfigValues } from "../types/ServiceSyncTypes.js";
+/**
+ * Write a maintenance plan into the tenant's Outlook calendar.
+ *
+ * The counterpart of `ServiceCalendarSyncPoller`; called from the
+ * `Service_Schedule` afterSave hook. Silent when the tenant has no calendar
+ * connection — the sync is opt-in per tenant, and a missing connection is not
+ * an error.
+ *
+ * Four cases, in this order:
+ *
+ * 1. plan archived or inactive → the appointment is removed; maintenance that
+ *    no longer happens must not sit in someone's calendar;
+ * 2. plan has no date (manual, sensor- or meter-driven) → same, there is
+ *    nothing to show;
+ * 3. plan already linked → the event is updated in place, keeping the time of
+ *    day someone gave it in Outlook;
+ * 4. otherwise → a new event, and a meta entry that links the two.
+ */
+export declare function syncPlanToCalendar(plan: Service_Schedule): Promise<void>;
+export declare function connectionForTenant(tenant: Tenant | undefined): Promise<{
+    manager: CalendarManager;
+    values: ServiceSyncConfigValues;
+} | null>;

package/dist/features/openservice/serviceSchedules/calendarSync/service/syncPlanToCalendar.js

@@ -0,0 +1,122 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncPlanToCalendar = syncPlanToCalendar;
+exports.connectionForTenant = connectionForTenant;
+const node_1 = __importDefault(require("parse/node"));
+const CalendarManager_js_1 = require("../../../schedules/calendarSync/service/CalendarManager.js");
+const index_js_1 = require("../../../../../types/index.js");
+const outlookRecurrence_js_1 = require("../functions/outlookRecurrence.js");
+const planToEvent_js_1 = require("../functions/planToEvent.js");
+const ServiceSyncTypes_js_1 = require("../types/ServiceSyncTypes.js");
+const serviceCalendarMeta_js_1 = require("./serviceCalendarMeta.js");
+/**
+ * Write a maintenance plan into the tenant's Outlook calendar.
+ *
+ * The counterpart of `ServiceCalendarSyncPoller`; called from the
+ * `Service_Schedule` afterSave hook. Silent when the tenant has no calendar
+ * connection — the sync is opt-in per tenant, and a missing connection is not
+ * an error.
+ *
+ * Four cases, in this order:
+ *
+ * 1. plan archived or inactive → the appointment is removed; maintenance that
+ *    no longer happens must not sit in someone's calendar;
+ * 2. plan has no date (manual, sensor- or meter-driven) → same, there is
+ *    nothing to show;
+ * 3. plan already linked → the event is updated in place, keeping the time of
+ *    day someone gave it in Outlook;
+ * 4. otherwise → a new event, and a meta entry that links the two.
+ */
+async function syncPlanToCalendar(plan) {
+    const connection = await connectionForTenant(plan.get("tenant"));
+    if (!connection)
+        return;
+    // A recurrence Outlook cannot express is left untouched rather than
+    // approximated — a wrong maintenance date in a calendar is worse than none.
+    const unsupported = (0, outlookRecurrence_js_1.calendarUnsupportedReason)(plan.get("cadence"));
+    if (unsupported) {
+        console.warn(`[ServiceCalendarSync] Plan ${plan.id} not synced: ${unsupported}`);
+        return;
+    }
+    const meta = await (0, serviceCalendarMeta_js_1.findMetaForPlan)(plan.id);
+    const values = meta ? (0, serviceCalendarMeta_js_1.metaValues)(meta) : undefined;
+    const eventId = values?.microsoftCalendarEventId;
+    const retired = !!plan.get("deletedAt") || plan.get("active") === false;
+    const event = retired
+        ? undefined
+        : (0, planToEvent_js_1.planToEvent)({
+            title: plan.get("title"),
+            cadence: plan.get("cadence"),
+            steps: plan.get("steps"),
+            notifications: plan.get("notifications"),
+            equipmentName: await equipmentLabel(plan),
+            snapshot: values?.microsoftCalendarEvent,
+        });
+    if (!event) {
+        if (meta && eventId) {
+            await connection.manager.deleteEvent(eventId);
+            await meta.destroy({ useMasterKey: true });
+        }
+        return;
+    }
+    if (meta && eventId) {
+        const updated = await connection.manager.updateEvent(eventId, event);
+        if (updated?.changeKey) {
+            await (0, serviceCalendarMeta_js_1.updateChangeKey)(meta, updated.changeKey, updated);
+        }
+        return;
+    }
+    const created = await connection.manager.createEvent(event);
+    if (!created?.id)
+        return;
+    await (0, serviceCalendarMeta_js_1.saveMeta)(plan.id, created.id, created.changeKey, plan.get("tenant"), created);
+}
+/** The machine's label, for the subject prefix — `undefined` if it has none. */
+async function equipmentLabel(plan) {
+    const equipment = plan.get("equipment");
+    if (!equipment)
+        return undefined;
+    // A pointer straight from a save is unfetched; the label lives on the object.
+    if (!equipment.get("label")) {
+        try {
+            await equipment.fetch({ useMasterKey: true });
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return equipment.get("label") || undefined;
+}
+async function connectionForTenant(tenant) {
+    if (!tenant)
+        return null;
+    const config = await new node_1.default.Query(index_js_1.Config)
+        .equalTo("key", ServiceSyncTypes_js_1.OUTLOOK_CONFIG_KEY)
+        .equalTo("tenant", tenant)
+        .first({ useMasterKey: true });
+    if (!config)
+        return null;
+    let values;
+    try {
+        values = JSON.parse(config.get("value"));
+    }
+    catch {
+        console.error(`[ServiceCalendarSync] Config ${config.id} does not contain valid JSON`);
+        return null;
+    }
+    const manager = new CalendarManager_js_1.CalendarManager({
+        tenantId: values.tenant_id,
+        clientID: values.client_id,
+        clientSecret: values.client_secret,
+        userMail: values.user_email,
+    });
+    const valid = manager.isValid;
+    if (valid !== true) {
+        console.warn(`[ServiceCalendarSync] Connection unusable: ${valid}`);
+        return null;
+    }
+    return { manager, values };
+}

package/dist/features/openservice/serviceSchedules/calendarSync/types/ServiceSyncTypes.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Config key of the Outlook integration. Shared with v1 — one calendar
+ * connection per tenant serves both generations.
+ */
+export declare const OUTLOOK_CONFIG_KEY = "OPENSERVICE_MICROSOFT_OUTLOOK_INTEGRATION";
+/**
+ * The stored configuration of one tenant's calendar connection.
+ *
+ * `default_source_id` is v1's fallback (a `Maintenance_Source`);
+ * `default_equipment_id` is its v2 counterpart (`OD3_Service_Equipment`). Both
+ * live in the same row because the connection is the same — the poller for each
+ * generation reads the key it understands.
+ */
+export type ServiceSyncConfigValues = {
+    tenant_id: string;
+    client_id: string;
+    client_secret: string;
+    user_email: string;
+    /** v1 fallback source. */
+    default_source_id?: string;
+    /** v2 fallback machine for events that name none. */
+    default_equipment_id?: string;
+    /** Delta cursor of the v1 poller. */
+    delta_link?: string;
+    /** Delta cursor of the v2 poller — separate, so the two never steal each other's. */
+    delta_link_v2?: string;
+};
+/**
+ * The recurrence of a v2 maintenance plan, as stored in
+ * `OD3_Service_Schedule.cadence`.
+ *
+ * Mirrored from `@opendash/plugin-openservice-core` (a browser package); the
+ * authoritative definition is the Parse schema. Only `rrule` and `manual` are
+ * active in v2.0, and only `rrule` can be represented in a calendar.
+ */
+export type ServiceCadence = {
+    kind: "rrule" | "sensor" | "meter" | "event" | "manual";
+    /** RFC 5545 recurrence rule, without the `RRULE:` prefix. */
+    rrule?: string;
+    /** ISO timestamp of the series start. */
+    dtstart?: string;
+    /** ISO timestamp the series ends at (inclusive). */
+    until?: string;
+};
+/** A notification rule of a plan (`notifications`), as far as the sync needs it. */
+export type ServiceNotificationRule = {
+    id: string;
+    trigger: "before" | "due";
+    offsetDays?: number;
+    assignedRoles?: boolean;
+    serviceProviders?: boolean;
+    userIds?: string[];
+    roleIds?: string[];
+    contactIds?: string[];
+};

package/dist/features/openservice/serviceSchedules/calendarSync/types/ServiceSyncTypes.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OUTLOOK_CONFIG_KEY = void 0;
+/**
+ * Config key of the Outlook integration. Shared with v1 — one calendar
+ * connection per tenant serves both generations.
+ */
+exports.OUTLOOK_CONFIG_KEY = "OPENSERVICE_MICROSOFT_OUTLOOK_INTEGRATION";

package/dist/features/openservice/serviceSchedules/initServiceSchedulesFeature.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Start the v2 side of the Outlook sync — one poller per configured tenant.
+ *
+ * The connections are read once at boot, like v1 does: a tenant that switches
+ * the sync on gets it after the next server start. The pollers are kept so a
+ * future reload can stop them instead of doubling them up.
+ */
+export declare function initServiceSchedulesFeature(): Promise<void>;
+/** Stop every poller — for tests and for a graceful shutdown. */
+export declare function stopServiceSchedulesFeature(): void;

package/dist/features/openservice/serviceSchedules/initServiceSchedulesFeature.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initServiceSchedulesFeature = initServiceSchedulesFeature;
+exports.stopServiceSchedulesFeature = stopServiceSchedulesFeature;
+const node_1 = __importDefault(require("parse/node"));
+const index_js_1 = require("../../../types/index.js");
+const ServiceCalendarSyncPoller_js_1 = require("./calendarSync/service/ServiceCalendarSyncPoller.js");
+const ServiceSyncTypes_js_1 = require("./calendarSync/types/ServiceSyncTypes.js");
+/** How often the delta feed is asked for changes. */
+const POLL_INTERVAL_MS = 60 * 1000;
+const pollers = [];
+/**
+ * Start the v2 side of the Outlook sync — one poller per configured tenant.
+ *
+ * The connections are read once at boot, like v1 does: a tenant that switches
+ * the sync on gets it after the next server start. The pollers are kept so a
+ * future reload can stop them instead of doubling them up.
+ */
+async function initServiceSchedulesFeature() {
+    const configs = await new node_1.default.Query(index_js_1.Config)
+        .equalTo("key", ServiceSyncTypes_js_1.OUTLOOK_CONFIG_KEY)
+        .includeAll()
+        .findAll({ useMasterKey: true });
+    for (const config of configs) {
+        pollers.push(new ServiceCalendarSyncPoller_js_1.ServiceCalendarSyncPoller(config).start(POLL_INTERVAL_MS));
+    }
+    if (pollers.length > 0) {
+        console.log(`[ServiceCalendarSync] Started for ${pollers.length} calendar connection(s)`);
+    }
+}
+/** Stop every poller — for tests and for a graceful shutdown. */
+function stopServiceSchedulesFeature() {
+    for (const poller of pollers)
+        poller.stop();
+    pollers.length = 0;
+}