@openinc/parse-server-opendash 4.1.1 → 4.1.2

package/dist/scripts/migration/lib/ticket.js

@@ -0,0 +1,192 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TicketNumberer = void 0;
+exports.loadRoleNames = loadRoleNames;
+exports.ticketAcl = ticketAcl;
+exports.loadTicketAcls = loadTicketAcls;
+const node_1 = __importDefault(require("parse/node"));
+const acl_js_1 = require("./acl.js");
+const pass_js_1 = require("./pass.js");
+/**
+ * Ticket numbering and ACLs, which the migration has to do itself.
+ *
+ * Normally `beforeSave(OD3_Service_Ticket)` handles both. But migration mode
+ * suppresses beforeSave registration entirely — the only way Parse will honour a
+ * historical `createdAt`, because `RestWrite` replaces the write payload with the
+ * trigger's `Parse.Object` round-trip, which discards the field (see
+ * `features/schema/services/beforeSaveHook.ts`). So the two things that hook did
+ * are reimplemented here, deliberately mirroring
+ * `hooks/Service_Ticket.ts` — keep them in sync.
+ */
+// ── Numbering ──────────────────────────────────────────────────────────────
+const COUNTER_CLASS = "OD3_Service_TicketCounter";
+/**
+ * Hands out `Ticket.number` the way the backend hook would.
+ *
+ * Per-project when the ticket has one (`Project.ticketCounter`), otherwise
+ * per-tenant (`OD3_Service_TicketCounter.value`).
+ *
+ * Counters are seeded from their **current** stored values and flushed once at the
+ * end, rather than incremented per ticket. That is both far fewer round trips and
+ * safe for a re-run: an already-migrated ticket keeps the number it has and
+ * consumes nothing, so a resumed run continues the sequence instead of restarting
+ * it. Safe precisely because the migration is single-threaded — the hook needs
+ * atomic `$inc` because concurrent clients race; here nothing else is writing.
+ */
+class TicketNumberer {
+    config;
+    projectCounters = new Map();
+    tenantCounters = new Map();
+    tenantCounterIds = new Map();
+    dirtyProjects = new Set();
+    dirtyTenants = new Set();
+    constructor(config) {
+        this.config = config;
+    }
+    /** Read the current counter values so numbering continues rather than restarts. */
+    async load() {
+        for await (const page of (0, pass_js_1.pages)(() => new node_1.default.Query("OD3_Service_Project"), this.config.batchSize)) {
+            for (const project of page) {
+                if (project.id) {
+                    this.projectCounters.set(project.id, project.get("ticketCounter") ?? 0);
+                }
+            }
+        }
+        for await (const page of (0, pass_js_1.pages)(() => new node_1.default.Query(COUNTER_CLASS), this.config.batchSize)) {
+            for (const counter of page) {
+                const tenantId = (0, pass_js_1.refId)(counter.get("tenant"));
+                if (!tenantId || !counter.id)
+                    continue;
+                this.tenantCounters.set(tenantId, counter.get("value") ?? 0);
+                this.tenantCounterIds.set(tenantId, counter.id);
+            }
+        }
+    }
+    /**
+     * The next number for a ticket, or undefined when there is no scope to count in
+     * (no project and no tenant) — matching the hook, which leaves those unnumbered.
+     */
+    next(projectId, tenantId) {
+        if (projectId) {
+            const value = (this.projectCounters.get(projectId) ?? 0) + 1;
+            this.projectCounters.set(projectId, value);
+            this.dirtyProjects.add(projectId);
+            return value;
+        }
+        if (tenantId) {
+            const value = (this.tenantCounters.get(tenantId) ?? 0) + 1;
+            this.tenantCounters.set(tenantId, value);
+            this.dirtyTenants.add(tenantId);
+            return value;
+        }
+        return undefined;
+    }
+    /**
+     * Persist the counters.
+     *
+     * Must run even if the pass had per-ticket errors: leaving a counter behind the
+     * numbers already handed out would make the *next* run reuse them, producing
+     * duplicates that `verify.ts` would then flag.
+     */
+    async flush() {
+        let projects = 0;
+        for (const projectId of this.dirtyProjects) {
+            const project = new node_1.default.Object("OD3_Service_Project");
+            project.id = projectId;
+            project.set("ticketCounter", this.projectCounters.get(projectId) ?? 0);
+            await project.save(null, acl_js_1.MIGRATION_SAVE);
+            projects += 1;
+        }
+        let tenants = 0;
+        for (const tenantId of this.dirtyTenants) {
+            const value = this.tenantCounters.get(tenantId) ?? 0;
+            const existingId = this.tenantCounterIds.get(tenantId);
+            const counter = new node_1.default.Object(COUNTER_CLASS);
+            if (existingId)
+                counter.id = existingId;
+            else {
+                counter.set("tenant", {
+                    __type: "Pointer",
+                    className: "OD3_Tenant",
+                    objectId: tenantId,
+                });
+            }
+            counter.set("value", value);
+            await counter.save(null, acl_js_1.MIGRATION_SAVE);
+            if (!existingId && counter.id)
+                this.tenantCounterIds.set(tenantId, counter.id);
+            tenants += 1;
+        }
+        return { projects, tenants };
+    }
+}
+exports.TicketNumberer = TicketNumberer;
+// ── ACLs ───────────────────────────────────────────────────────────────────
+/** Role id → role name, needed because Parse ACLs grant by name, not by id. */
+async function loadRoleNames(config) {
+    const names = new Map();
+    for await (const page of (0, pass_js_1.pages)(() => new node_1.default.Query(node_1.default.Role), config.batchSize)) {
+        for (const role of page) {
+            const name = role.getName();
+            if (role.id && name)
+                names.set(role.id, name);
+        }
+    }
+    return names;
+}
+/**
+ * The ACL a v2 ticket should carry.
+ *
+ * `migrationAcl` covers what `defaultAclHandler` would have granted (od-admin and
+ * the tenant roles); this adds what `setTicketACL` would have granted on top —
+ * creator and assignees, read and write.
+ *
+ * Note the hook cannot actually do the assignee half today: it reads the arrays via
+ * a helper that takes `.id` off each entry, but the entity adapter stores
+ * array-of-ref fields as plain id **strings**, so it always resolves to nothing.
+ * Here we use the ids directly, so migrated tickets end up with the grants the hook
+ * was intended to give. That is a deliberate divergence, not an oversight.
+ */
+function ticketAcl(options) {
+    const acl = (0, acl_js_1.migrationAcl)({
+        tenantId: options.tenantId,
+        userId: options.creatorId,
+        allowTenantUserWrite: true,
+    });
+    acl.setPublicReadAccess(false);
+    acl.setPublicWriteAccess(false);
+    for (const userId of options.assignedUserIds) {
+        acl.setReadAccess(userId, true);
+        acl.setWriteAccess(userId, true);
+    }
+    for (const roleId of options.assignedRoleIds) {
+        const name = options.roleNames.get(roleId);
+        if (!name)
+            continue; // stale role reference — nothing to grant
+        acl.setRoleReadAccess(name, true);
+        acl.setRoleWriteAccess(name, true);
+    }
+    return acl;
+}
+/**
+ * The ACLs of the already-migrated v2 tickets, keyed by ticket id.
+ *
+ * Pass 12 needs these twice: the reconstructed changelog entry must carry the ACL
+ * of the ticket it describes (normally `beforeSave(OD3_Changelog)` mirrors it from
+ * the snapshot, but that trigger is suppressed too), and the snapshot itself should
+ * show the v2 ACL rather than the v1 one.
+ */
+async function loadTicketAcls(config) {
+    const acls = new Map();
+    for await (const page of (0, pass_js_1.pages)(() => new node_1.default.Query("OD3_Service_Ticket"), config.batchSize)) {
+        for (const ticket of page) {
+            const acl = ticket.getACL();
+            if (ticket.id && acl)
+                acls.set(ticket.id, acl);
+        }
+    }
+    return acls;
+}

package/dist/scripts/migration/passes/01-statuses.d.ts

@@ -0,0 +1,12 @@
+import { type Pass } from "../lib/pass.js";
+/**
+ * Pass 01 — `OD3_Maintenance_Kanban_State` → `OD3_Service_Status`.
+ *
+ * Runs first because everything else needs a Status to point at: `Ticket.status`
+ * is required, so pass 08 needs a fallback for tickets that never had a kanban
+ * row, and pass 04 sets `Project.defaultStatus`.
+ *
+ * Small by design — 5–10 rows per tenant — which makes it the right pass to
+ * establish the shape the others copy, and cheap to eyeball after a run.
+ */
+export declare const pass01: Pass;

package/dist/scripts/migration/passes/01-statuses.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.pass01 = void 0;
+const node_1 = __importDefault(require("parse/node"));
+const index_js_1 = require("../../../types/index.js");
+const acl_js_1 = require("../lib/acl.js");
+const map_js_1 = require("../lib/map.js");
+const pass_js_1 = require("../lib/pass.js");
+function categoryOf(state) {
+    if (state.get("isInbox"))
+        return "inbox";
+    if (state.get("isFinished"))
+        return "done";
+    return "active";
+}
+/**
+ * Pass 01 — `OD3_Maintenance_Kanban_State` → `OD3_Service_Status`.
+ *
+ * Runs first because everything else needs a Status to point at: `Ticket.status`
+ * is required, so pass 08 needs a fallback for tickets that never had a kanban
+ * row, and pass 04 sets `Project.defaultStatus`.
+ *
+ * Small by design — 5–10 rows per tenant — which makes it the right pass to
+ * establish the shape the others copy, and cheap to eyeball after a run.
+ */
+exports.pass01 = {
+    id: "01",
+    title: "statuses",
+    needs: [],
+    async run({ config, map, report, entry }) {
+        const states = await (0, pass_js_1.all)(() => (0, pass_js_1.scopeToTenant)(new node_1.default.Query(index_js_1.Maintenance_Kanban_State), config.tenantId), config.batchSize);
+        if (states.length === 0) {
+            report.warn(entry, "no Maintenance_Kanban_State rows found — pass 08 will have no status to fall back to");
+            return;
+        }
+        let inboxSeen = 0;
+        for (const state of states) {
+            // Parse types `id` as optional; a row returned by a query always has one,
+            // so an absent id means something is wrong rather than something to skip
+            // silently.
+            const sourceId = state.id;
+            if (!sourceId) {
+                report.error(entry, "a Kanban_State row came back without an objectId");
+                continue;
+            }
+            const category = categoryOf(state);
+            if (category === "inbox")
+                inboxSeen += 1;
+            const existingId = map.get(index_js_1.Maintenance_Kanban_State.className, sourceId);
+            const target = existingId
+                ? new index_js_1.Service_Status({ objectId: existingId })
+                : new index_js_1.Service_Status();
+            const tenantId = (0, pass_js_1.refId)(state.get("tenant"));
+            target.set("label", state.get("label"));
+            target.set("category", category);
+            target.set("order", state.get("order"));
+            // v1 hides anything that is not exactly `enabled === true` — every v1 query
+            // filters `.equalTo("enabled", true)`. So `undefined` means hidden there, and
+            // `!== true` (not `=== false`) is what reproduces that. The schema defaults the
+            // column to true, so this only differs for rows predating that default — but
+            // getting it wrong would resurrect records v1 deliberately hid.
+            target.set("deleted", state.get("enabled") !== true);
+            if (state.get("color"))
+                target.set("color", state.get("color"));
+            if (tenantId) {
+                target.set("tenant", {
+                    __type: "Pointer",
+                    className: "OD3_Tenant",
+                    objectId: tenantId,
+                });
+            }
+            // `description` has no column on Service_Status and is dropped (A1); say so
+            // rather than losing it silently.
+            if (state.get("description")) {
+                report.warn(entry, `Kanban_State ${sourceId} ("${state.get("label")}") drops description: ` +
+                    `"${state.get("description")}"`);
+            }
+            if (!existingId) {
+                // Master data, not user-owned: no userId, and tenant users may write it —
+                // matching how the entity admin creates these today.
+                target.setACL((0, acl_js_1.migrationAcl)({ tenantId, allowTenantUserWrite: true }));
+            }
+            if (config.dryRun) {
+                existingId ? entry.updated++ : entry.created++;
+                // Pass 08 resolves each ticket's status through this map; without a
+                // placeholder every ticket in a dry run would warn "no Status".
+                if (!existingId) {
+                    await map.record(index_js_1.Maintenance_Kanban_State.className, sourceId, index_js_1.Service_Status.className, map_js_1.MigrationMap.dryId(sourceId));
+                }
+                continue;
+            }
+            try {
+                const newId = await (0, acl_js_1.saveMigrated)(config, target, {
+                    className: index_js_1.Service_Status.className,
+                    isNew: !existingId,
+                    createdAt: state.createdAt,
+                    updatedAt: state.updatedAt,
+                });
+                if (existingId) {
+                    entry.updated++;
+                }
+                else {
+                    entry.created++;
+                    await map.record(index_js_1.Maintenance_Kanban_State.className, sourceId, index_js_1.Service_Status.className, newId);
+                }
+            }
+            catch (error) {
+                report.error(entry, `Kanban_State ${sourceId} failed: ${error.message}`);
+            }
+        }
+        if (inboxSeen === 0) {
+            report.warn(entry, "no state had isInbox — pass 08 has no inbox Status to use as the " +
+                "required-status fallback. Mark one manually before running 08.");
+        }
+        else if (inboxSeen > 1) {
+            report.warn(entry, `${inboxSeen} states had isInbox — pass 08 will pick the oldest as the fallback`);
+        }
+    },
+};

package/dist/scripts/migration/passes/02-tags.d.ts

@@ -0,0 +1,13 @@
+import { type Pass } from "../lib/pass.js";
+/**
+ * Pass 02 — `OD3_Maintenance_Issuecategory` → `OD3_Service_Tag`.
+ *
+ * v2 replaced issue categories with the generic tag tree, scoped per object type
+ * via `Tag.type`. Ticket categories therefore become tags typed to
+ * `OD3_Service_Ticket`.
+ *
+ * Dropped, per MIGRATION_PLAN A2 and decisions D1: `icon` and `issuecode` (no
+ * column on Tag), `catchall` (becomes "no tag"), and the `source` relation (tags
+ * are not source-scoped in v2). Each drop is reported.
+ */
+export declare const pass02: Pass;

package/dist/scripts/migration/passes/02-tags.js

@@ -0,0 +1,150 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pass02 = void 0;
+const node_1 = __importDefault(require("parse/node"));
+const index_js_1 = require("../../../types/index.js");
+const acl_js_1 = require("../lib/acl.js");
+const map_js_1 = require("../lib/map.js");
+const ptr_js_1 = require("../lib/ptr.js");
+const pass_js_1 = require("../lib/pass.js");
+/**
+ * Order categories so a parent is always written before its children.
+ *
+ * Two reasons this matters. `Tag.parent` needs the parent's *new* id, which only
+ * exists once the parent is written; and `afterSave(Service_Tag)` reconciles stored
+ * ancestor closures when a tag is re-parented — inserting depth-first keeps every
+ * save a create rather than a re-parent.
+ *
+ * Cycles (a category that is its own ancestor) would otherwise loop forever, so
+ * anything unreachable after a full sweep is returned separately for reporting
+ * rather than silently dropped.
+ */
+function topoSort(rows) {
+    const byId = new Map();
+    for (const r of rows)
+        if (r.id)
+            byId.set(r.id, r);
+    const ordered = [];
+    const placed = new Set();
+    let progressed = true;
+    while (progressed) {
+        progressed = false;
+        for (const row of rows) {
+            if (!row.id || placed.has(row.id))
+                continue;
+            const parentId = (0, pass_js_1.refId)(row.get("parent"));
+            // Placeable when it has no parent, or a parent outside this set (already
+            // gone), or a parent that is already placed.
+            if (!parentId || !byId.has(parentId) || placed.has(parentId)) {
+                ordered.push(row);
+                placed.add(row.id);
+                progressed = true;
+            }
+        }
+    }
+    return {
+        ordered,
+        unreachable: rows.filter((r) => r.id && !placed.has(r.id)),
+    };
+}
+/**
+ * Pass 02 — `OD3_Maintenance_Issuecategory` → `OD3_Service_Tag`.
+ *
+ * v2 replaced issue categories with the generic tag tree, scoped per object type
+ * via `Tag.type`. Ticket categories therefore become tags typed to
+ * `OD3_Service_Ticket`.
+ *
+ * Dropped, per MIGRATION_PLAN A2 and decisions D1: `icon` and `issuecode` (no
+ * column on Tag), `catchall` (becomes "no tag"), and the `source` relation (tags
+ * are not source-scoped in v2). Each drop is reported.
+ */
+exports.pass02 = {
+    id: "02",
+    title: "tags",
+    needs: [],
+    async run({ config, map, report, entry }) {
+        const categories = await (0, pass_js_1.all)(() => (0, pass_js_1.scopeToTenant)(new node_1.default.Query(index_js_1.Maintenance_Issuecategory), config.tenantId), config.batchSize);
+        if (categories.length === 0)
+            return;
+        const { ordered, unreachable } = topoSort(categories);
+        for (const row of unreachable) {
+            report.error(entry, `Issuecategory ${row.id} is in a parent cycle and was not migrated`);
+        }
+        let droppedCodes = 0;
+        for (const category of ordered) {
+            const sourceId = category.id;
+            if (!sourceId)
+                continue;
+            const existingId = map.get(index_js_1.Maintenance_Issuecategory.className, sourceId);
+            const target = existingId
+                ? new index_js_1.Service_Tag({ objectId: existingId })
+                : new index_js_1.Service_Tag();
+            const tenantId = (0, pass_js_1.refId)(category.get("tenant"));
+            const parentSourceId = (0, pass_js_1.refId)(category.get("parent"));
+            const parentTargetId = parentSourceId
+                ? map.get(index_js_1.Maintenance_Issuecategory.className, parentSourceId)
+                : undefined;
+            if (parentSourceId && !parentTargetId) {
+                // topoSort guarantees the parent came first, so this means the parent
+                // itself failed to save.
+                report.error(entry, `Issuecategory ${sourceId} ("${category.get("name")}") lost its parent ` +
+                    `${parentSourceId} — parent was not migrated`);
+            }
+            target.set("label", category.get("name"));
+            target.set("type", index_js_1.Service_Ticket.className);
+            // v1 hides anything that is not exactly `enabled === true` — every v1 query
+            // filters `.equalTo("enabled", true)`. So `undefined` means hidden there, and
+            // `!== true` (not `=== false`) is what reproduces that. The schema defaults the
+            // column to true, so this only differs for rows predating that default — but
+            // getting it wrong would resurrect records v1 deliberately hid.
+            target.set("deleted", category.get("enabled") !== true);
+            const parentPtr = (0, ptr_js_1.maybePtr)(index_js_1.Service_Tag.className, parentTargetId);
+            if (parentPtr)
+                target.set("parent", parentPtr);
+            if (tenantId)
+                target.set("tenant", (0, ptr_js_1.tenantPtr)(tenantId));
+            if (category.get("issuecode"))
+                droppedCodes += 1;
+            if (category.get("icon")) {
+                report.warn(entry, `Issuecategory ${sourceId} drops icon "${category.get("icon")}"`);
+            }
+            if (!existingId) {
+                target.setACL((0, acl_js_1.migrationAcl)({ tenantId, allowTenantUserWrite: true }));
+            }
+            if (config.dryRun) {
+                existingId ? entry.updated++ : entry.created++;
+                // Dry runs still need the mapping in memory so children resolve a parent.
+                if (!existingId) {
+                    await map.record(index_js_1.Maintenance_Issuecategory.className, sourceId, index_js_1.Service_Tag.className, map_js_1.MigrationMap.dryId(sourceId));
+                }
+                continue;
+            }
+            try {
+                const newId = await (0, acl_js_1.saveMigrated)(config, target, {
+                    className: index_js_1.Service_Tag.className,
+                    isNew: !existingId,
+                    createdAt: category.createdAt,
+                    updatedAt: category.updatedAt,
+                });
+                if (existingId) {
+                    entry.updated++;
+                }
+                else {
+                    entry.created++;
+                    await map.record(index_js_1.Maintenance_Issuecategory.className, sourceId, index_js_1.Service_Tag.className, newId);
+                }
+            }
+            catch (error) {
+                report.error(entry, `Issuecategory ${sourceId} failed: ${error.message}`);
+                continue;
+            }
+        }
+        if (droppedCodes > 0) {
+            report.info(entry, `${droppedCodes} categor(ies) had an issuecode, which has no column on Tag ` +
+                `and was dropped (D1)`);
+        }
+    },
+};

package/dist/scripts/migration/passes/03-equipment.d.ts

@@ -0,0 +1,14 @@
+import { type Pass } from "../lib/pass.js";
+/**
+ * Pass 03 — `OD3_Source` → `OD3_Service_Equipment`.
+ *
+ * The one genuine remodelling in the migration. v1 attaches tickets to a data
+ * source; v2 attaches them to Equipment, which is only loosely coupled back to
+ * sources through `Equipment.sourceTags`.
+ *
+ * `source.tag` is not unique — several sources can carry the same tag — so
+ * Equipment→Source is deliberately not a bijection. Storing the tag string rather
+ * than a source id is the documented intent (see the openservice-core equipment
+ * README).
+ */
+export declare const pass03: Pass;