@openinc/parse-server-opendash 4.1.1 → 4.1.2

package/dist/scripts/migration/passes/10-chat.js

@@ -0,0 +1,230 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pass10 = 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 latest_js_1 = require("../lib/latest.js");
+const message_js_1 = require("../lib/message.js");
+const pass_js_1 = require("../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.
+ */
+exports.pass10 = {
+    id: "10",
+    title: "chat",
+    needs: ["08"],
+    async run({ config, map, report, entry }) {
+        const messages = await (0, pass_js_1.all)(() => (0, pass_js_1.scopeToTenant)(new node_1.default.Query(index_js_1.Maintenance_Message), config.tenantId), config.batchSize);
+        if (messages.length === 0)
+            return;
+        // Todos became Ticket.checklist in pass 08. v1's own machine-generated change
+        // log (type "system") is dropped: pass 12 reconstructs that history properly as
+        // changelog entries, so migrating it as chat too would duplicate the timeline
+        // and fill the thread with untranslated i18n keys. See lib/message.ts.
+        const systemGenerated = messages.filter((m) => (0, message_js_1.isSystemGenerated)(m)).length;
+        const comments = messages.filter((m) => !(0, message_js_1.isTodo)(m) && !(0, message_js_1.isSystemGenerated)(m));
+        // Replies after their parents. v1 replies are shallow in practice, but a
+        // depth sort costs nothing and removes the assumption.
+        const byId = new Map();
+        for (const m of comments)
+            if (m.id)
+                byId.set(m.id, m);
+        const depth = (message) => {
+            let d = 0;
+            let cursor = (0, pass_js_1.refId)(message.get("replyTo"));
+            const guard = new Set();
+            while (cursor && byId.has(cursor) && !guard.has(cursor)) {
+                guard.add(cursor);
+                d += 1;
+                cursor = (0, pass_js_1.refId)(byId.get(cursor).get("replyTo"));
+            }
+            return d;
+        };
+        const ordered = [...comments].sort((a, b) => {
+            const byDepth = depth(a) - depth(b);
+            if (byDepth !== 0)
+                return byDepth;
+            return (a.createdAt?.getTime() ?? 0) - (b.createdAt?.getTime() ?? 0);
+        });
+        let orphaned = 0;
+        let attachmentsMigrated = 0;
+        for (const message of ordered) {
+            const sourceId = message.id;
+            if (!sourceId)
+                continue;
+            const oldTicketId = message.get("referencedObjectId");
+            const newTicketId = oldTicketId
+                ? map.get(index_js_1.Maintenance_Ticket.className, oldTicketId)
+                : undefined;
+            if (!newTicketId) {
+                // A message can reference something other than a ticket (`classname` is
+                // free-form in v1), so this is expected noise rather than an error.
+                orphaned += 1;
+                entry.skipped++;
+                continue;
+            }
+            const existingId = map.get(index_js_1.Maintenance_Message.className, sourceId);
+            const target = existingId
+                ? new index_js_1.Chat_Message({ objectId: existingId })
+                : new index_js_1.Chat_Message();
+            const tenantIdOfMessage = (0, pass_js_1.refId)(message.get("tenant"));
+            const authorId = (0, pass_js_1.refId)(message.get("user"));
+            const contextString = (0, ptr_js_1.contextToString)((0, ptr_js_1.ticketContext)(newTicketId));
+            // v1 had a title and a body; the chat has one text field. A real subject
+            // becomes a bold first line — but v1 stores an i18n *key* there when the user
+            // left the subject blank, and rendering that key would be visible nonsense.
+            // See lib/message.ts.
+            const text = (0, message_js_1.chatText)(message);
+            if (!text) {
+                // `Chat_Message.text` is required.
+                report.warn(entry, `message ${sourceId} has no usable text — skipped`);
+                entry.skipped++;
+                continue;
+            }
+            target.set("context", contextString);
+            target.set("text", text);
+            target.set("deleted", false);
+            if (authorId)
+                target.set("author", (0, ptr_js_1.userPtr)(authorId));
+            if (tenantIdOfMessage) {
+                target.set("tenant", (0, ptr_js_1.tenantPtr)(tenantIdOfMessage));
+            }
+            const replyToSourceId = (0, pass_js_1.refId)(message.get("replyTo"));
+            const replyToTargetId = replyToSourceId
+                ? map.get(index_js_1.Maintenance_Message.className, replyToSourceId)
+                : undefined;
+            const parentPtr = (0, ptr_js_1.maybePtr)(index_js_1.Chat_Message.className, replyToTargetId);
+            if (parentPtr)
+                target.set("parent", parentPtr);
+            else if (replyToSourceId) {
+                report.warn(entry, `message ${sourceId} replies to ${replyToSourceId}, which was not migrated ` +
+                    `— it becomes a top-level comment`);
+            }
+            // ── media → Assets rows + attachments ──────────────────────────────────
+            const attachments = [];
+            const mediaRows = (await (0, latest_js_1.relationObjects)(message, "media", config.batchSize));
+            for (const media of mediaRows) {
+                const file = media.get("media");
+                const url = file?.url();
+                if (!url) {
+                    report.warn(entry, `media ${media.id} has no file — skipped`);
+                    continue;
+                }
+                const name = media.get("description") || file?.name() || "Datei";
+                // Reuse the Assets row on a re-run rather than duplicating the file.
+                let assetId = media.id
+                    ? map.get(index_js_1.Maintenance_Media.className, media.id)
+                    : undefined;
+                // `OD3_Assets.user` is required by the schema, but v1's
+                // `Maintenance_Message.user` is optional — so an author-less comment
+                // cannot become a library entry. Keep it as a URL-only attachment
+                // (still visible in the chat) rather than failing the whole message.
+                if (!assetId && !config.dryRun && media.id && !authorId) {
+                    report.warn(entry, `media ${media.id} on message ${sourceId} has no author; ` +
+                        `OD3_Assets.user is required, so it stays a URL-only attachment ` +
+                        `and will not appear in the ticket's asset library`);
+                }
+                if (!assetId && !config.dryRun && media.id && authorId) {
+                    const asset = new index_js_1.Assets();
+                    asset.set("context", contextString);
+                    asset.set("description", name);
+                    asset.set("file", file);
+                    asset.set("user", (0, ptr_js_1.userPtr)(authorId));
+                    if (tenantIdOfMessage) {
+                        asset.set("tenant", (0, ptr_js_1.tenantPtr)(tenantIdOfMessage));
+                    }
+                    asset.setACL((0, acl_js_1.migrationAcl)({
+                        tenantId: tenantIdOfMessage,
+                        userId: authorId,
+                        allowTenantUserWrite: true,
+                    }));
+                    try {
+                        assetId = await (0, acl_js_1.saveMigrated)(config, asset, {
+                            className: index_js_1.Assets.className,
+                            isNew: true,
+                            createdAt: media.createdAt,
+                            updatedAt: media.updatedAt,
+                        });
+                        if (assetId) {
+                            await map.record(index_js_1.Maintenance_Media.className, media.id, index_js_1.Assets.className, assetId);
+                            attachmentsMigrated += 1;
+                        }
+                    }
+                    catch (error) {
+                        report.error(entry, `media ${media.id} → Assets failed: ${error.message}`);
+                    }
+                }
+                attachments.push({
+                    name,
+                    url,
+                    ...(assetId ? { assetId } : {}),
+                });
+            }
+            if (attachments.length)
+                target.set("attachments", attachments);
+            if (!existingId) {
+                target.setACL((0, acl_js_1.migrationAcl)({
+                    tenantId: tenantIdOfMessage,
+                    userId: authorId,
+                    allowTenantUserWrite: true,
+                }));
+            }
+            if (config.dryRun) {
+                existingId ? entry.updated++ : entry.created++;
+                if (!existingId) {
+                    await map.record(index_js_1.Maintenance_Message.className, sourceId, index_js_1.Chat_Message.className, map_js_1.MigrationMap.dryId(sourceId));
+                }
+                continue;
+            }
+            try {
+                const newId = await (0, acl_js_1.saveMigrated)(config, target, {
+                    className: index_js_1.Chat_Message.className,
+                    isNew: !existingId,
+                    createdAt: message.createdAt,
+                    updatedAt: message.updatedAt,
+                });
+                if (existingId) {
+                    entry.updated++;
+                }
+                else {
+                    entry.created++;
+                    await map.record(index_js_1.Maintenance_Message.className, sourceId, index_js_1.Chat_Message.className, newId);
+                }
+            }
+            catch (error) {
+                report.error(entry, `message ${sourceId} failed: ${error.message}`);
+            }
+        }
+        if (systemGenerated > 0) {
+            report.info(entry, `${systemGenerated} v1 system-generated change-log message(s) skipped — ` +
+                `pass 12 reconstructs that history as changelog entries instead`);
+            entry.skipped += systemGenerated;
+        }
+        if (orphaned > 0) {
+            report.info(entry, `${orphaned} message(s) referenced an object that is not a migrated ticket ` +
+                `(v1 'referencedObjectId' is not ticket-only) — skipped`);
+        }
+        if (attachmentsMigrated > 0) {
+            report.info(entry, `${attachmentsMigrated} Maintenance_Media file(s) became Assets rows in the ` +
+                `ticket context`);
+        }
+    },
+};

package/dist/scripts/migration/passes/11-assets.d.ts

@@ -0,0 +1,17 @@
+import { type Pass } from "../lib/pass.js";
+/**
+ * Pass 11 — re-address v1 ticket uploads onto the v2 ticket context.
+ *
+ * v1's ticket form wrote uploads to `OD3_Assets` with
+ * `context = "ticket-media-<ticketId>"`. v2 addresses everything attached to a
+ * ticket by the stringified context array `["service","ticket",<id>]` — the same
+ * key the chat uses — and the detail page renders an `AssetLibrary` on it.
+ *
+ * So the files themselves need no copying: only the `context` string changes, from
+ * the v1 prefix form to the v2 array form, carrying the *new* ticket id.
+ *
+ * v1 also wrote `ticket-media-temp-<uuid>` contexts while a ticket was still being
+ * created. Those are orphans by definition (the ticket id was unknown), and are
+ * reported rather than rewritten.
+ */
+export declare const pass11: Pass;

package/dist/scripts/migration/passes/11-assets.js

@@ -0,0 +1,93 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pass11 = 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");
+/** The v1 context prefix the ticket form wrote uploads under. */
+const LEGACY_PREFIX = "ticket-media-";
+/**
+ * Pass 11 — re-address v1 ticket uploads onto the v2 ticket context.
+ *
+ * v1's ticket form wrote uploads to `OD3_Assets` with
+ * `context = "ticket-media-<ticketId>"`. v2 addresses everything attached to a
+ * ticket by the stringified context array `["service","ticket",<id>]` — the same
+ * key the chat uses — and the detail page renders an `AssetLibrary` on it.
+ *
+ * So the files themselves need no copying: only the `context` string changes, from
+ * the v1 prefix form to the v2 array form, carrying the *new* ticket id.
+ *
+ * v1 also wrote `ticket-media-temp-<uuid>` contexts while a ticket was still being
+ * created. Those are orphans by definition (the ticket id was unknown), and are
+ * reported rather than rewritten.
+ */
+exports.pass11 = {
+    id: "11",
+    title: "assets",
+    needs: ["08"],
+    async run({ config, map, report, entry }) {
+        let tempContexts = 0;
+        let unmapped = 0;
+        // Collect the full set BEFORE writing anything.
+        //
+        // This pass is the one place where the rows being written are the same rows
+        // being read: rewriting `context` removes the asset from
+        // `startsWith(LEGACY_PREFIX)`. Paging that query with `skip` while shrinking
+        // its result set makes every page after the first jump over unprocessed rows —
+        // with a 500-row batch and 1000 assets, roughly half would be silently missed.
+        // Reading everything up front costs one array of small objects and removes the
+        // hazard entirely.
+        const assets = await (0, pass_js_1.all)(() => new node_1.default.Query(index_js_1.Assets).startsWith("context", LEGACY_PREFIX), config.batchSize);
+        for (const asset of assets) {
+            const context = asset.get("context");
+            if (!context)
+                continue;
+            const suffix = context.slice(LEGACY_PREFIX.length);
+            if (suffix.startsWith("temp-")) {
+                // Left behind by an abandoned create; there is no ticket to attach to.
+                tempContexts += 1;
+                entry.skipped++;
+                continue;
+            }
+            const newTicketId = map.get(index_js_1.Maintenance_Ticket.className, suffix);
+            if (!newTicketId) {
+                unmapped += 1;
+                entry.skipped++;
+                continue;
+            }
+            const nextContext = (0, ptr_js_1.contextToString)((0, ptr_js_1.ticketContext)(newTicketId));
+            if (context === nextContext) {
+                entry.skipped++;
+                continue;
+            }
+            if (config.dryRun) {
+                entry.updated++;
+                continue;
+            }
+            asset.set("context", nextContext);
+            try {
+                // Only the context changes — the file, its ACL and its timestamps are
+                // deliberately left alone. An update, so it goes over the SDK: Parse ignores
+                // a supplied createdAt on update anyway.
+                await asset.save(null, acl_js_1.MIGRATION_SAVE);
+                entry.updated++;
+            }
+            catch (error) {
+                report.error(entry, `asset ${asset.id} context rewrite failed: ${error.message}`);
+            }
+        }
+        if (tempContexts > 0) {
+            report.info(entry, `${tempContexts} asset(s) still on a "ticket-media-temp-*" context — orphans ` +
+                `from abandoned ticket creation, left as they are`);
+        }
+        if (unmapped > 0) {
+            report.info(entry, `${unmapped} asset(s) reference a ticket id that was not migrated — left as ` +
+                `they are (their ticket may be outside the --tenant scope)`);
+        }
+    },
+};

package/dist/scripts/migration/passes/12-history.d.ts

@@ -0,0 +1,24 @@
+import { type Pass } from "../lib/pass.js";
+/**
+ * Pass 12 — replay the v1 side tables into `OD3_Changelog`.
+ *
+ * The v2 ticket detail page already aggregates changelog entries for
+ * `OD3_Service_Ticket` by objectId and renders each field through that field's own
+ * Display component, so entries written here need no UI work to show up.
+ *
+ * Three things this depends on and cannot work around:
+ *
+ * - **Historical `createdAt`.** The timeline sorts, groups and labels purely by
+ *   `entry.createdAt`. Under the master key Parse would stamp `now` on every entry
+ *   and the whole trail would collapse onto the migration date.
+ * - **`ACL` inside the snapshot.** `beforeSave(OD3_Changelog)` mirrors the changed
+ *   object's ACL, read from `value.ACL` / `original.ACL`. Omit it and history ends
+ *   up more restrictive than the ticket it describes.
+ * - **Parse wire types in the snapshot.** `{__type:"Pointer"}` / `{__type:"Date"}`
+ *   are what make the diff render reference pills and dates instead of raw JSON.
+ *
+ * By construction the final snapshot of the replay equals the flat ticket pass 08
+ * wrote — which `verify.ts` checks, and which is the strongest signal in the whole
+ * migration that both halves agree.
+ */
+export declare const pass12: Pass;