@openinc/parse-server-opendash 4.1.1 → 4.1.2

package/dist/scripts/migration/passes/08-tickets.js

@@ -0,0 +1,353 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pass08 = exports.legacyOrigin = void 0;
+exports.closureOf = closureOf;
+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 ticket_js_1 = require("../lib/ticket.js");
+const latest_js_1 = require("../lib/latest.js");
+const material_js_1 = require("../lib/material.js");
+const message_js_1 = require("../lib/message.js");
+const ptr_js_1 = require("../lib/ptr.js");
+const pass_js_1 = require("../lib/pass.js");
+/** Marker written to `Ticket.origin` so a v2 ticket can be traced back. */
+const legacyOrigin = (oldTicketId) => `legacy:${oldTicketId}`;
+exports.legacyOrigin = legacyOrigin;
+/**
+ * The ancestor closure of a tag, as v2 stores it.
+ *
+ * v2 entities store the picked tag *plus every ancestor*, which turns "has tag X"
+ * into a flat indexable query that also matches descendants. Writing only the
+ * picked tag would silently break every hierarchical filter.
+ */
+function closureOf(tagId, parentOf) {
+    const closure = [];
+    let cursor = tagId;
+    const guard = new Set();
+    while (cursor && !guard.has(cursor)) {
+        guard.add(cursor);
+        closure.push(cursor);
+        cursor = parentOf.get(cursor);
+    }
+    return closure;
+}
+/**
+ * Pass 08 — the fold. `OD3_Maintenance_Ticket` (+ ~10 side tables) →
+ * `OD3_Service_Ticket`.
+ *
+ * Two things about the ordering are load-bearing:
+ *
+ * 1. Tickets are inserted in **ascending `createdAt`**, because insert order
+ *    becomes numbering order and chronological insertion is what reproduces a
+ *    sensible sequence. The backend `beforeSave` that normally assigns `number`
+ *    is not registered in migration mode, so `TicketNumberer` (lib/ticket.ts)
+ *    hands the numbers out in-process and flushes `Project.ticketCounter` once
+ *    at the end of this pass.
+ * 2. Every side table is loaded **once** and grouped in memory (see `lib/latest`),
+ *    not queried per ticket.
+ */
+exports.pass08 = {
+    id: "08",
+    title: "tickets",
+    needs: ["01", "02", "03", "04", "05"],
+    async run({ config, map, report, entry }) {
+        const { batchSize, tenantId } = config;
+        // ── Fallback status, per tenant ───────────────────────────────────────────
+        // `Ticket.status` is required, so a ticket that never had a kanban row still
+        // needs one, and the inbox status is the honest default.
+        //
+        // Resolved **per tenant**, not once per run. A single fallback was only ever
+        // correct when `--tenant` scoped the whole run; on a whole-database run it
+        // picked the globally-oldest inbox status and put it on every tenant's
+        // unstatused tickets — a cross-tenant reference that the ticket's own tenant
+        // could not even read, so the status column rendered empty in the UI.
+        const inboxByTenant = new Map();
+        for (const status of await (0, pass_js_1.all)(() => (0, pass_js_1.scopeToTenant)(new node_1.default.Query(index_js_1.Service_Status).equalTo("category", "inbox"), tenantId), batchSize)) {
+            const statusTenantId = (0, pass_js_1.refId)(status.get("tenant"));
+            // Oldest wins, matching pass 01's "picks the oldest as the fallback" note.
+            if (statusTenantId && status.id && !inboxByTenant.has(statusTenantId)) {
+                inboxByTenant.set(statusTenantId, status.id);
+            }
+        }
+        if (inboxByTenant.size === 0 && !config.dryRun) {
+            report.error(entry, "no inbox Status exists — every ticket without a kanban row would be " +
+                "unwritable. Run pass 01 first, or mark one v1 kanban state as isInbox.");
+            return;
+        }
+        if (inboxByTenant.size === 0) {
+            // A dry run against a database where v2 is still empty legitimately has no
+            // Status yet — pass 01 wrote nothing. Aborting here would make the full
+            // `--dry-run` (the review step this whole design leans on) impossible, so
+            // carry on with a placeholder and say so once.
+            report.warn(entry, "dry run: no inbox Status exists yet, using a placeholder. Run passes 01-07 " +
+                "for real before judging this pass's output.");
+        }
+        // ── Numbering + role names ───────────────────────────────────────────────
+        // beforeSave is not registered in migration mode (it is what would strip the
+        // historical createdAt), so the numbering and ACL work that hook normally does
+        // happens here instead. See lib/ticket.ts.
+        const numberer = new ticket_js_1.TicketNumberer(config);
+        await numberer.load();
+        const roleNames = await (0, ticket_js_1.loadRoleNames)(config);
+        // ── Tag parent map, for closure expansion ────────────────────────────────
+        const parentOf = new Map();
+        for (const tag of await (0, pass_js_1.all)(() => new node_1.default.Query(index_js_1.Service_Tag), batchSize)) {
+            if (tag.id)
+                parentOf.set(tag.id, (0, pass_js_1.refId)(tag.get("parent")));
+        }
+        // ── Side tables, one query each ──────────────────────────────────────────
+        const scoped = (cls) => () => (0, pass_js_1.scopeToTenant)(new node_1.default.Query(cls), tenantId);
+        const titles = await (0, latest_js_1.groupByTicket)(scoped(index_js_1.Maintenance_Ticket_Title), batchSize);
+        const priorities = await (0, latest_js_1.groupByTicket)(scoped(index_js_1.Maintenance_Priority), batchSize);
+        const downtimes = await (0, latest_js_1.groupByTicket)(scoped(index_js_1.Maintenance_Downtime), batchSize);
+        const frequencies = await (0, latest_js_1.groupByTicket)(scoped(index_js_1.Maintenance_Frequency), batchSize);
+        const restrictions = await (0, latest_js_1.groupByTicket)(scoped(index_js_1.Maintenance_Restriction), batchSize);
+        const duedates = await (0, latest_js_1.groupByTicket)(scoped(index_js_1.Maintenance_Duedate), batchSize);
+        const sources = await (0, latest_js_1.groupByTicket)(scoped(index_js_1.Maintenance_Ticket_Source), batchSize);
+        const projectRows = await (0, latest_js_1.groupByTicket)(scoped(index_js_1.Maintenance_Ticket_Project), batchSize);
+        const categories = await (0, latest_js_1.groupByTicket)(scoped(index_js_1.Maintenance_Ticket_Issuecategory), batchSize);
+        const stateHistory = await (0, latest_js_1.groupByTicket)(scoped(index_js_1.Maintenance_Ticket_Kanban_State), batchSize);
+        const currentStates = await (0, latest_js_1.groupByTicket)(scoped(index_js_1.Maintenance_Ticket_Kanban_State_Current), batchSize);
+        const materials = await (0, latest_js_1.groupByTicket)(scoped(index_js_1.Maintenance_Ticket_Material), batchSize);
+        // Which kanban states count as finished, for deriving `closedAt`.
+        const finishedStateIds = new Set();
+        for (const state of await (0, pass_js_1.all)(() => (0, pass_js_1.scopeToTenant)(new node_1.default.Query(index_js_1.Maintenance_Kanban_State), tenantId), batchSize)) {
+            if (state.id && state.get("isFinished"))
+                finishedStateIds.add(state.id);
+        }
+        // Todo messages become the checklist; comments are pass 10's job.
+        const messages = new Map();
+        for await (const page of (0, pass_js_1.pages)(() => (0, pass_js_1.scopeToTenant)(new node_1.default.Query(index_js_1.Maintenance_Message), tenantId), batchSize)) {
+            for (const message of page) {
+                const ticketId = message.get("referencedObjectId");
+                if (!ticketId)
+                    continue;
+                const bucket = messages.get(ticketId);
+                if (bucket)
+                    bucket.push(message);
+                else
+                    messages.set(ticketId, [message]);
+            }
+        }
+        // ── Fold, ticket by ticket, oldest first ─────────────────────────────────
+        for await (const page of (0, pass_js_1.pages)(() => (0, pass_js_1.scopeToTenant)(new node_1.default.Query(index_js_1.Maintenance_Ticket), tenantId), batchSize)) {
+            for (const ticket of page) {
+                const sourceId = ticket.id;
+                if (!sourceId)
+                    continue;
+                const ticketTenantId = (0, pass_js_1.refId)(ticket.get("tenant"));
+                if (!ticketTenantId) {
+                    report.error(entry, `ticket ${sourceId} has no tenant; Ticket.tenant is required — skipped`);
+                    entry.skipped++;
+                    continue;
+                }
+                const existingId = map.get(index_js_1.Maintenance_Ticket.className, sourceId);
+                const target = existingId
+                    ? new index_js_1.Service_Ticket({ objectId: existingId })
+                    : new index_js_1.Service_Ticket();
+                // ── title: latest override, else the ticket's own ────────────────────
+                const latestTitle = (0, latest_js_1.latestOf)(titles.get(sourceId));
+                const title = latestTitle?.get("title") ?? ticket.get("title") ?? `Ticket ${sourceId}`;
+                target.set("title", title);
+                // ── flat scalars ────────────────────────────────────────────────────
+                if (ticket.get("description")) {
+                    target.set("description", ticket.get("description"));
+                }
+                // v1 lists only `enabled === true` tickets (see
+                // functions/openinc-openservice-ticket-data.ts), so `undefined` means hidden
+                // there too. `!== true` reproduces that; `=== false` would resurrect records
+                // v1 deliberately hid. Disabled tickets migrate as deleted rather than being
+                // skipped, so nothing is lost.
+                target.set("deleted", ticket.get("enabled") !== true);
+                target.set("tenant", (0, ptr_js_1.tenantPtr)(ticketTenantId));
+                target.set("origin", (0, exports.legacyOrigin)(sourceId));
+                // Priority is already 0–100 in v1 and v1's five thresholds
+                // (20/40/60/80/100) each land in a sensible v2 bucket, so it copies
+                // straight across with no rescaling.
+                const priority = ticket.get("latestPriorityValue") ??
+                    (0, latest_js_1.latestOf)(priorities.get(sourceId))?.get("value");
+                // A v1 ticket could carry no priority at all. v2 renders an unset
+                // priority as "-", which reads as missing data rather than as a value,
+                // so it defaults to the bottom bucket (0 = the lowest of v2s four
+                // levels) instead of being left absent.
+                target.set("priority", typeof priority === "number" ? priority : 0);
+                const downtime = (0, latest_js_1.latestOf)(downtimes.get(sourceId))?.get("value");
+                if (typeof downtime === "number")
+                    target.set("downtime", downtime);
+                const frequency = (0, latest_js_1.latestOf)(frequencies.get(sourceId))?.get("value");
+                if (typeof frequency === "number")
+                    target.set("frequency", frequency);
+                const restriction = (0, latest_js_1.latestOf)(restrictions.get(sourceId))?.get("value");
+                if (typeof restriction === "number")
+                    target.set("restriction", restriction);
+                // ── dates ───────────────────────────────────────────────────────────
+                const duedate = (0, latest_js_1.latestOf)(duedates.get(sourceId));
+                if (duedate?.get("end"))
+                    target.set("dueDate", duedate.get("end"));
+                if (duedate?.get("start")) {
+                    target.set("startDate", duedate.get("start"));
+                }
+                else if (ticket.get("displayAt")) {
+                    // D5: displayAt meant "hide until"; startDate is the closest v2 field,
+                    // and only used where a real start date is absent.
+                    target.set("startDate", ticket.get("displayAt"));
+                }
+                // ── status (required) ───────────────────────────────────────────────
+                const currentStateRow = (0, latest_js_1.latestOf)(currentStates.get(sourceId));
+                const historicStateRow = (0, latest_js_1.latestOf)(stateHistory.get(sourceId));
+                const v1StateId = (0, pass_js_1.refId)(currentStateRow?.get("state")) ?? (0, pass_js_1.refId)(historicStateRow?.get("state"));
+                const statusId = v1StateId
+                    ? map.get(index_js_1.Maintenance_Kanban_State.className, v1StateId)
+                    : undefined;
+                // The fallback must belong to *this ticket's* tenant.
+                const fallbackStatusId = inboxByTenant.get(ticketTenantId) ??
+                    map_js_1.MigrationMap.dryId(`inbox-status-${ticketTenantId}`);
+                if (!statusId && !inboxByTenant.has(ticketTenantId) && !config.dryRun) {
+                    report.error(entry, `ticket ${sourceId} needs the inbox fallback but tenant ${ticketTenantId} ` +
+                        `has no inbox Status — mark one of its v1 kanban states as isInbox and ` +
+                        `re-run passes 01 and 08`);
+                    entry.skipped++;
+                    continue;
+                }
+                target.set("status", (0, ptr_js_1.maybePtr)(index_js_1.Service_Status.className, statusId ?? fallbackStatusId));
+                if (v1StateId && !statusId) {
+                    report.warn(entry, `ticket ${sourceId} referenced kanban state ${v1StateId}, which has no ` +
+                        `Status — fell back to inbox`);
+                }
+                // ── closedAt, derived from the state history ────────────────────────
+                // v1 has no closedAt: the closest truth is when the ticket last entered a
+                // finished state.
+                const finishedEntry = (stateHistory.get(sourceId) ?? [])
+                    .filter((row) => {
+                    const id = (0, pass_js_1.refId)(row.get("state"));
+                    return id ? finishedStateIds.has(id) : false;
+                })
+                    .sort((a, b) => (a.updatedAt?.getTime() ?? 0) - (b.updatedAt?.getTime() ?? 0))
+                    .pop();
+                if (finishedEntry?.updatedAt) {
+                    target.set("closedAt", finishedEntry.updatedAt);
+                }
+                // ── equipment, project, tags ────────────────────────────────────────
+                const v1SourceId = (0, pass_js_1.refId)((0, latest_js_1.latestOf)(sources.get(sourceId))?.get("source"));
+                const equipmentId = v1SourceId
+                    ? map.get(index_js_1.Source.className, v1SourceId)
+                    : undefined;
+                const equipmentPtr = (0, ptr_js_1.maybePtr)(index_js_1.Service_Equipment.className, equipmentId);
+                if (equipmentPtr)
+                    target.set("equipment", equipmentPtr);
+                else if (v1SourceId) {
+                    report.warn(entry, `ticket ${sourceId} referenced source ${v1SourceId}, which has no Equipment`);
+                }
+                // v1 wrote both the pointer and a side-table row; the pointer wins.
+                const v1ProjectId = (0, pass_js_1.refId)(ticket.get("project")) ??
+                    (0, pass_js_1.refId)((0, latest_js_1.latestOf)(projectRows.get(sourceId))?.get("project"));
+                const projectId = v1ProjectId
+                    ? map.get(index_js_1.Maintenance_Project.className, v1ProjectId)
+                    : undefined;
+                const projectPtr = (0, ptr_js_1.maybePtr)(index_js_1.Service_Project.className, projectId);
+                if (projectPtr)
+                    target.set("project", projectPtr);
+                const v1CategoryId = (0, pass_js_1.refId)((0, latest_js_1.latestOf)(categories.get(sourceId))?.get("issuecategory"));
+                const tagId = v1CategoryId
+                    ? map.get(index_js_1.Maintenance_Issuecategory.className, v1CategoryId)
+                    : undefined;
+                if (tagId)
+                    target.set("tags", closureOf(tagId, parentOf));
+                // ── assignees ───────────────────────────────────────────────────────
+                // v2 stores arrays of plain ids; the assignment *history* is pass 12's job.
+                const [userIds, roleIds] = await Promise.all([
+                    (0, latest_js_1.relationIds)(ticket, "assignedusers"),
+                    (0, latest_js_1.relationIds)(ticket, "assignedroles"),
+                ]);
+                if (userIds.length)
+                    target.set("assignedUsers", userIds);
+                if (roleIds.length)
+                    target.set("assignedRoles", roleIds);
+                const creatorId = (0, pass_js_1.refId)(ticket.get("user"));
+                if (creatorId)
+                    target.set("createdBy", (0, ptr_js_1.userPtr)(creatorId));
+                // ── checklist, from todo messages ───────────────────────────────────
+                // `isTodoDone` reads `data.todoCompleted` (v1's actual field) and
+                // `checklistLabel` skips v1's i18n-key placeholder titles — see lib/message.
+                const checklist = (messages.get(sourceId) ?? [])
+                    .filter((m) => (0, message_js_1.isTodo)(m))
+                    .sort((a, b) => (a.createdAt?.getTime() ?? 0) - (b.createdAt?.getTime() ?? 0))
+                    .map((m) => ({ label: (0, message_js_1.checklistLabel)(m), done: (0, message_js_1.isTodoDone)(m) }))
+                    .filter((item) => item.label !== undefined);
+                if (checklist.length)
+                    target.set("checklist", checklist);
+                // ── material, from the newest Ticket_Material row ───────────────────
+                // Each v1 row holds the whole list, so the fold is the latest row
+                // rather than a merge. Shared with pass 12 via lib/material.
+                const materialRow = (0, latest_js_1.latestOf)(materials.get(sourceId));
+                if (materialRow) {
+                    const { entries, unresolved } = (0, material_js_1.toMaterial)(materialRow.get("itemList"), map);
+                    if (entries.length)
+                        target.set("material", entries);
+                    if (unresolved.length) {
+                        report.warn(entry, `ticket ${sourceId} material references item(s) ` +
+                            `${unresolved.join(", ")} with no migrated Article — kept as ` +
+                            `free-text line(s)`);
+                    }
+                }
+                if (!existingId) {
+                    // Numbering: normally the backend hook's atomic increment. Safe to do
+                    // in-process because the migration is the only writer (lib/ticket.ts).
+                    const number = numberer.next(projectId, ticketTenantId);
+                    if (number !== undefined)
+                        target.set("number", number);
+                    else {
+                        report.warn(entry, `ticket ${sourceId} has neither project nor tenant scope — left unnumbered`);
+                    }
+                    // The full ticket ACL, including what `setTicketACL` would have added.
+                    target.setACL((0, ticket_js_1.ticketAcl)({
+                        tenantId: ticketTenantId,
+                        creatorId,
+                        assignedUserIds: userIds,
+                        assignedRoleIds: roleIds,
+                        roleNames,
+                    }));
+                }
+                if (config.dryRun) {
+                    existingId ? entry.updated++ : entry.created++;
+                    // Passes 09-12 are all keyed by the *new* ticket id. Without a
+                    // placeholder a full dry run would report an error per ticket in each of
+                    // them, drowning the findings the dry run is for.
+                    if (!existingId) {
+                        await map.record(index_js_1.Maintenance_Ticket.className, sourceId, index_js_1.Service_Ticket.className, map_js_1.MigrationMap.dryId(sourceId));
+                    }
+                    continue;
+                }
+                try {
+                    const newId = await (0, acl_js_1.saveMigrated)(config, target, {
+                        className: index_js_1.Service_Ticket.className,
+                        isNew: !existingId,
+                        createdAt: ticket.createdAt,
+                        updatedAt: ticket.updatedAt,
+                    });
+                    if (existingId) {
+                        entry.updated++;
+                    }
+                    else {
+                        entry.created++;
+                        await map.record(index_js_1.Maintenance_Ticket.className, sourceId, index_js_1.Service_Ticket.className, newId);
+                    }
+                }
+                catch (error) {
+                    report.error(entry, `ticket ${sourceId} failed: ${error.message}`);
+                }
+            }
+        }
+        // Always flush, even after errors: counters that lag behind the numbers already
+        // handed out would make the next run reuse them and produce duplicates.
+        if (!config.dryRun) {
+            const flushed = await numberer.flush();
+            report.info(entry, `counters updated: ${flushed.projects} project(s), ${flushed.tenants} tenant counter(s)`);
+        }
+    },
+};

package/dist/scripts/migration/passes/09-ticket-meta.d.ts

@@ -0,0 +1,12 @@
+import { type Pass } from "../lib/pass.js";
+/**
+ * Pass 09 — per-ticket meta values → `OD3_Meta_Entry`.
+ *
+ * v1 kept the field definition and its value together in
+ * `Maintenance_Ticket.meta = { fields: [{ name, type, label, …, value }] }`. v2
+ * separates them: pass 07 wrote the shared definition list, this pass writes each
+ * ticket's values.
+ *
+ * `entryObjectId` must be the **new** ticket id, so this depends on pass 08.
+ */
+export declare const pass09: Pass;

package/dist/scripts/migration/passes/09-ticket-meta.js

@@ -0,0 +1,136 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pass09 = 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 ptr_js_1 = require("../lib/ptr.js");
+const pass_js_1 = require("../lib/pass.js");
+const _07_meta_configs_js_1 = require("./07-meta-configs.js");
+/** Addressed by constant so the REST create path gets the right class name. */
+const MetaEntryClass = index_js_1.Meta_Entry.className;
+/**
+ * Pass 09 — per-ticket meta values → `OD3_Meta_Entry`.
+ *
+ * v1 kept the field definition and its value together in
+ * `Maintenance_Ticket.meta = { fields: [{ name, type, label, …, value }] }`. v2
+ * separates them: pass 07 wrote the shared definition list, this pass writes each
+ * ticket's values.
+ *
+ * `entryObjectId` must be the **new** ticket id, so this depends on pass 08.
+ */
+exports.pass09 = {
+    id: "09",
+    title: "ticket-meta",
+    needs: ["07", "08"],
+    async run({ config, map, report, entry }) {
+        const contextString = (0, ptr_js_1.contextToString)(_07_meta_configs_js_1.TICKET_META_CONTEXT);
+        // Pass 07 writes one Meta_Config **per tenant**, so `origin` has to resolve
+        // per tenant too — pointing every entry at whichever config happened to come
+        // back first would cross-link tenants. Read with the maintenance key, which
+        // bypasses the ACLs that normally do this scoping.
+        const configByTenant = new Map();
+        for await (const page of (0, pass_js_1.pages)(() => new node_1.default.Query(index_js_1.Meta_Config).equalTo("context", contextString), config.batchSize)) {
+            for (const row of page) {
+                if (row.id)
+                    configByTenant.set((0, pass_js_1.refId)(row.get("tenant")) ?? "", row.id);
+            }
+        }
+        if (configByTenant.size === 0) {
+            report.warn(entry, "no Meta_Config for the ticket context — entries will be written without " +
+                "an `origin` (run pass 07 first)");
+        }
+        // Existing entries, so a re-run updates rather than duplicates. Keyed by the
+        // ticket the entry belongs to.
+        const existingByTicket = new Map();
+        for await (const page of (0, pass_js_1.pages)(() => new node_1.default.Query(index_js_1.Meta_Entry)
+            .equalTo("context", contextString)
+            .equalTo("entryClassName", index_js_1.Service_Ticket.className), config.batchSize)) {
+            for (const row of page) {
+                const objectId = row.get("entryObjectId");
+                if (objectId)
+                    existingByTicket.set(objectId, row);
+            }
+        }
+        for await (const page of (0, pass_js_1.pages)(() => (0, pass_js_1.scopeToTenant)(new node_1.default.Query(index_js_1.Maintenance_Ticket), config.tenantId).exists("meta"), config.batchSize)) {
+            for (const ticket of page) {
+                const sourceId = ticket.id;
+                if (!sourceId)
+                    continue;
+                const meta = ticket.get("meta");
+                const fields = meta?.fields ?? [];
+                if (fields.length === 0)
+                    continue;
+                const newTicketId = map.get(index_js_1.Maintenance_Ticket.className, sourceId);
+                if (!newTicketId) {
+                    report.error(entry, `ticket ${sourceId} has meta but no migrated ticket — run pass 08 first`);
+                    continue;
+                }
+                // Values only; the definitions are the shared config's job. A field whose
+                // value was never set is skipped rather than written as null.
+                const values = {};
+                const snapshot = [];
+                for (const field of fields) {
+                    const converted = (0, _07_meta_configs_js_1.toMetaFieldConfig)(field);
+                    if (!converted)
+                        continue;
+                    snapshot.push(converted);
+                    if (field.value !== undefined && field.value !== null) {
+                        values[converted.name] = field.value;
+                    }
+                }
+                if (Object.keys(values).length === 0) {
+                    entry.skipped++;
+                    continue;
+                }
+                const existing = existingByTicket.get(newTicketId);
+                const target = existing ?? new index_js_1.Meta_Entry();
+                const ticketTenantId = (0, pass_js_1.refId)(ticket.get("tenant"));
+                target.set("context", contextString);
+                target.set("entryClassName", index_js_1.Service_Ticket.className);
+                target.set("entryObjectId", newTicketId);
+                target.set("values", values);
+                // The meta plugin stores a config snapshot alongside the values so an entry
+                // still renders after the shared config changes. Mirror that.
+                target.set("config", { fields: snapshot });
+                const originPtr = (0, ptr_js_1.maybePtr)(index_js_1.Meta_Config.className, configByTenant.get(ticketTenantId ?? "") ?? configByTenant.get(""));
+                if (originPtr)
+                    target.set("origin", originPtr);
+                else if (configByTenant.size > 0) {
+                    report.warn(entry, `ticket ${sourceId} (tenant ${ticketTenantId ?? "none"}) has no ` +
+                        `Meta_Config for its tenant — entry written without an origin`);
+                }
+                if (ticketTenantId) {
+                    target.set("tenant", (0, ptr_js_1.tenantPtr)(ticketTenantId));
+                }
+                if (!existing) {
+                    target.setACL((0, acl_js_1.migrationAcl)({
+                        tenantId: ticketTenantId,
+                        allowTenantUserWrite: true,
+                    }));
+                }
+                if (config.dryRun) {
+                    existing ? entry.updated++ : entry.created++;
+                    continue;
+                }
+                try {
+                    // The entry is as old as the ticket it describes — v1 kept no separate
+                    // timestamp for it.
+                    await (0, acl_js_1.saveMigrated)(config, target, {
+                        className: MetaEntryClass,
+                        isNew: !existing,
+                        createdAt: ticket.createdAt,
+                        updatedAt: ticket.updatedAt,
+                    });
+                    existing ? entry.updated++ : entry.created++;
+                }
+                catch (error) {
+                    report.error(entry, `meta entry for ticket ${sourceId} failed: ${error.message}`);
+                }
+            }
+        }
+    },
+};

package/dist/scripts/migration/passes/10-chat.d.ts

@@ -0,0 +1,17 @@
+import { type Pass } from "../lib/pass.js";
+/**
+ * Pass 10 — v1 comments → `OD3_Chat_Message`, with their media as attachments.
+ *
+ * `Maintenance_Message` splits two ways: rows whose `data.type` is `"todo"` became
+ * `Ticket.checklist` in pass 08; everything else is a comment and lands here.
+ *
+ * Attachments: `Maintenance_Media` rows are bare Parse Files with no `OD3_Assets`
+ * row behind them. Rather than leaving them as URL-only attachments, this pass
+ * creates an `OD3_Assets` row per file in the ticket's shared context, so a legacy
+ * comment attachment also shows up in the detail page's asset library — the same
+ * place pass 11 puts the form-uploaded files. One destination regardless of which
+ * v1 store held the file.
+ *
+ * Ordering: top-level messages are written before replies, so `parent` resolves.
+ */
+export declare const pass10: Pass;