@openinc/parse-server-opendash 4.1.1 → 4.1.2

package/dist/scripts/migration/passes/06-formconfigs.d.ts

@@ -0,0 +1,17 @@
+import { type Pass } from "../lib/pass.js";
+/**
+ * Pass 06 — `OD3_Maintenance_Ticket_FormConfig` → `OD3_Service_FormConfig`.
+ *
+ * Two representation changes: v1 stored an `Object` column, v2 stores
+ * JSON-serialised strings (`fields`, `rules`); and v1's `roles` Relation becomes a
+ * plain array of role ids.
+ *
+ * `view` ("steps" | "formular" | "compact") has no v2 counterpart — v2 renders one
+ * form — so it is dropped with a note.
+ *
+ * The v1 `config` shape is only partly knowable from the type definitions, so this
+ * pass is defensive: anything it does not recognise is reported with the raw key
+ * rather than dropped silently. Expect to revisit it after the first dry run
+ * against real data.
+ */
+export declare const pass06: Pass;

package/dist/scripts/migration/passes/06-formconfigs.js

@@ -0,0 +1,166 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pass06 = 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 latest_js_1 = require("../lib/latest.js");
+const ptr_js_1 = require("../lib/ptr.js");
+const pass_js_1 = require("../lib/pass.js");
+/**
+ * v1 field key → v2 `FieldConfigEntry.key`.
+ *
+ * v1 configured the *form input*; v2 configures the *ticket field*, so a couple of
+ * v1 keys fan out (`duedate` covered both ends of a range; `assignedTo` covered
+ * users and roles together) and two have no v2 field at all.
+ */
+const FIELD_KEY_MAP = {
+    title: ["title"],
+    description: ["description"],
+    priority: ["priority"],
+    duedate: ["dueDate", "startDate"],
+    state: ["status"],
+    source: ["equipment"],
+    issuecategory: ["tags"],
+    project: ["project"],
+    assignedTo: ["assignedUsers", "assignedRoles"],
+    material: ["material"],
+    // `media` is now the asset library (no per-field config) and is reported
+    // rather than mapped. `material` used to be dropped with it; it now has a
+    // real v2 column, so the form-config entry carries across.
+};
+/**
+ * Pass 06 — `OD3_Maintenance_Ticket_FormConfig` → `OD3_Service_FormConfig`.
+ *
+ * Two representation changes: v1 stored an `Object` column, v2 stores
+ * JSON-serialised strings (`fields`, `rules`); and v1's `roles` Relation becomes a
+ * plain array of role ids.
+ *
+ * `view` ("steps" | "formular" | "compact") has no v2 counterpart — v2 renders one
+ * form — so it is dropped with a note.
+ *
+ * The v1 `config` shape is only partly knowable from the type definitions, so this
+ * pass is defensive: anything it does not recognise is reported with the raw key
+ * rather than dropped silently. Expect to revisit it after the first dry run
+ * against real data.
+ */
+exports.pass06 = {
+    id: "06",
+    title: "formconfigs",
+    needs: [],
+    async run({ config, map, report, entry }) {
+        const sources = await (0, pass_js_1.all)(() => (0, pass_js_1.scopeToTenant)(new node_1.default.Query(index_js_1.Maintenance_Ticket_FormConfig), config.tenantId), config.batchSize);
+        if (sources.length === 0)
+            return;
+        for (const source of sources) {
+            const sourceId = source.id;
+            if (!sourceId)
+                continue;
+            const existingId = map.get(index_js_1.Maintenance_Ticket_FormConfig.className, sourceId);
+            const target = existingId
+                ? new index_js_1.Service_FormConfig({ objectId: existingId })
+                : new index_js_1.Service_FormConfig();
+            const tenantId = (0, pass_js_1.refId)(source.get("tenant"));
+            const view = source.get("view");
+            // v1's `config` is `{ config: FieldConfigUnion[] }` in the UI types, but the
+            // column has been written by more than one generation of the form editor —
+            // accept either the wrapper or a bare array.
+            const raw = source.get("config");
+            const v1Fields = Array.isArray(raw)
+                ? raw
+                : Array.isArray(raw?.config)
+                    ? raw.config
+                    : [];
+            if (raw && v1Fields.length === 0) {
+                report.warn(entry, `FormConfig ${sourceId} has a config column this pass did not recognise: ` +
+                    `${JSON.stringify(raw).slice(0, 200)}`);
+            }
+            const v2Fields = [];
+            for (const field of v1Fields) {
+                if (!field?.name)
+                    continue;
+                const targetKeys = FIELD_KEY_MAP[field.name];
+                if (!targetKeys) {
+                    report.warn(entry, `FormConfig ${sourceId} field "${field.name}" has no per-field v2 ` +
+                        `config (media → asset library, meta → Meta_Config in pass 07) and was ` +
+                        `skipped`);
+                    continue;
+                }
+                // Priority's custom labels were keyed by v1 threshold label; v2 keys
+                // `valueLabels` by bucket value ("75" | "50" | "25" | "0"). The v1 labels
+                // are i18n keys, so a faithful remap needs the v1 threshold order — which
+                // is per-tenant config. Carry them across positionally and flag it.
+                let valueLabels;
+                if (field.name === "priority" && field.customLabels?.length) {
+                    const buckets = ["0", "25", "50", "75"];
+                    valueLabels = {};
+                    field.customLabels.forEach((entryLabel, index) => {
+                        const bucket = buckets[Math.min(index, buckets.length - 1)];
+                        valueLabels[bucket] = entryLabel.value;
+                    });
+                    report.warn(entry, `FormConfig ${sourceId} priority labels were remapped positionally onto ` +
+                        `v2's four buckets — check them by hand (v1 had five levels)`);
+                }
+                for (const key of targetKeys) {
+                    const converted = { key };
+                    if (field.hidden !== undefined)
+                        converted.hidden = field.hidden;
+                    if (field.required !== undefined)
+                        converted.required = field.required;
+                    // v1 used "-" to mean "render no label at all".
+                    if (field.label && field.label !== "-")
+                        converted.label = field.label;
+                    if (valueLabels)
+                        converted.valueLabels = valueLabels;
+                    v2Fields.push(converted);
+                }
+                if (field.help) {
+                    report.warn(entry, `FormConfig ${sourceId} field "${field.name}" drops help text ` +
+                        `("${field.help}") — v2 FieldConfigEntry has no help property`);
+                }
+            }
+            target.set("label", source.get("label") || (view ? `Formular (${view})` : `Formular ${sourceId}`));
+            target.set("fields", JSON.stringify(v2Fields));
+            if (tenantId)
+                target.set("tenant", (0, ptr_js_1.tenantPtr)(tenantId));
+            // `roles` Relation → array of role ids.
+            const roleIds = await (0, latest_js_1.relationIds)(source, "roles", config.batchSize);
+            if (roleIds.length)
+                target.set("roles", roleIds);
+            if (view) {
+                report.warn(entry, `FormConfig ${sourceId} drops view "${view}" — v2 renders a single form layout`);
+            }
+            if (!existingId) {
+                target.setACL((0, acl_js_1.migrationAcl)({ tenantId }));
+            }
+            if (config.dryRun) {
+                existingId ? entry.updated++ : entry.created++;
+                continue;
+            }
+            try {
+                const newId = await (0, acl_js_1.saveMigrated)(config, target, {
+                    className: index_js_1.Service_FormConfig.className,
+                    isNew: !existingId,
+                    createdAt: source.createdAt,
+                    updatedAt: source.updatedAt,
+                });
+                if (existingId) {
+                    entry.updated++;
+                }
+                else {
+                    entry.created++;
+                    await map.record(index_js_1.Maintenance_Ticket_FormConfig.className, sourceId, index_js_1.Service_FormConfig.className, newId);
+                }
+            }
+            catch (error) {
+                report.error(entry, `FormConfig ${sourceId} failed: ${error.message}`);
+            }
+        }
+        report.info(entry, `save-time rule sets live in OD3_Config[OPENSERVICE_RULESET_FUNCTIONS] and are ` +
+            `NOT migrated by this pass — v2 stores them per FormConfig in \`rules\`. ` +
+            `Port them by hand or extend this pass once the mapping is agreed.`);
+    },
+};

package/dist/scripts/migration/passes/07-meta-configs.d.ts

@@ -0,0 +1,46 @@
+import { type Pass } from "../lib/pass.js";
+/** Context the ticket meta config and its entries live under in v2. */
+export declare const TICKET_META_CONTEXT: string[];
+/** A v1 ticket meta field definition (also carries its value, per ticket). */
+export interface V1MetaField {
+    name?: string;
+    label?: string;
+    description?: string;
+    type?: string;
+    className?: string;
+    display?: string;
+    multiple?: boolean;
+    options?: string[];
+    min?: number;
+    max?: number;
+    value?: unknown;
+}
+/** A plugin-meta `MetaFieldConfig`. */
+interface V2MetaField {
+    name: string;
+    label: string;
+    type: string;
+    description?: string;
+    multiline?: boolean;
+    min?: number;
+    max?: number;
+    options?: Array<{
+        label: string;
+        value: string;
+    }>;
+    multiple?: boolean;
+    className?: string;
+    display?: string;
+}
+/**
+ * v1 meta field → plugin-meta field config.
+ *
+ * The type vocabularies line up almost exactly — `string | number | boolean | date
+ * | select | select_parse` — and plugin-meta still accepts `select_parse` as a
+ * deprecated alias of `select_entity`, so it is carried across unchanged rather
+ * than rewritten. That keeps the migration reversible and lets the meta plugin's
+ * own read-time alias do the work.
+ */
+export declare function toMetaFieldConfig(field: V1MetaField): V2MetaField | undefined;
+export declare const pass07: Pass;
+export {};

package/dist/scripts/migration/passes/07-meta-configs.js

@@ -0,0 +1,185 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pass07 = exports.TICKET_META_CONTEXT = void 0;
+exports.toMetaFieldConfig = toMetaFieldConfig;
+const node_1 = __importDefault(require("parse/node"));
+const index_js_1 = require("../../../types/index.js");
+const acl_js_1 = require("../lib/acl.js");
+const env_js_1 = require("../lib/env.js");
+const ptr_js_1 = require("../lib/ptr.js");
+const pass_js_1 = require("../lib/pass.js");
+/** Context the ticket meta config and its entries live under in v2. */
+exports.TICKET_META_CONTEXT = ["service", "ticket", "meta"];
+/**
+ * v1 meta field → plugin-meta field config.
+ *
+ * The type vocabularies line up almost exactly — `string | number | boolean | date
+ * | select | select_parse` — and plugin-meta still accepts `select_parse` as a
+ * deprecated alias of `select_entity`, so it is carried across unchanged rather
+ * than rewritten. That keeps the migration reversible and lets the meta plugin's
+ * own read-time alias do the work.
+ */
+function toMetaFieldConfig(field) {
+    const name = field.name?.trim();
+    if (!name)
+        return undefined;
+    const converted = {
+        name,
+        label: field.label?.trim() || name,
+        type: field.type ?? "string",
+    };
+    if (field.description)
+        converted.description = field.description;
+    if (typeof field.min === "number")
+        converted.min = field.min;
+    if (typeof field.max === "number")
+        converted.max = field.max;
+    if (field.multiple !== undefined)
+        converted.multiple = field.multiple;
+    if (field.type === "select" && field.options?.length) {
+        // v1 stored plain strings; plugin-meta wants {label, value} pairs.
+        converted.options = field.options.map((option) => ({
+            label: option,
+            value: option,
+        }));
+    }
+    if (field.type === "select_parse") {
+        if (field.className)
+            converted.className = field.className;
+        if (field.display)
+            converted.display = field.display;
+    }
+    return converted;
+}
+/**
+ * Pass 07 — v1 ticket meta field definitions → one `OD3_Meta_Config`.
+ *
+ * v1 denormalised config *and* value together into `Maintenance_Ticket.meta` on
+ * every ticket, plus a definition list on the form config. v2 splits them: one
+ * shared `Meta_Config` under context `["service","ticket","meta"]`, and one
+ * `Meta_Entry` per ticket (pass 09).
+ *
+ * Because no single v1 record holds the authoritative definition list, this pass
+ * unions every definition it can see — from the form configs and from the tickets
+ * themselves — and de-duplicates by field name. First definition wins; conflicting
+ * re-definitions are reported.
+ */
+/** Key used to bucket definitions per tenant. `""` means "no tenant". */
+const NO_TENANT = "";
+/**
+ * Look up the Meta_Config for one tenant.
+ *
+ * Scoped by tenant deliberately. `getMetaConfig()` in the meta plugin filters by
+ * *context only* and relies on Parse ACLs to show each tenant its own record — but
+ * this pass reads with the maintenance key, which bypasses ACL entirely. An
+ * unscoped `.first()` here would therefore find some other tenant's config and
+ * overwrite it, destroying that tenant's field definitions.
+ */
+async function findConfig(contextString, tenantId) {
+    const query = new node_1.default.Query(index_js_1.Meta_Config).equalTo("context", contextString);
+    if (tenantId)
+        query.equalTo("tenant", (0, ptr_js_1.tenantPtr)(tenantId));
+    else
+        query.doesNotExist("tenant");
+    return (await query.first(env_js_1.MK)) ?? undefined;
+}
+exports.pass07 = {
+    id: "07",
+    title: "meta-configs",
+    needs: [],
+    async run({ config, report, entry }) {
+        // Definitions are collected **per tenant**: one shared Meta_Config per tenant,
+        // matching how the meta plugin reads them back. Merging every tenant into one
+        // record would leak one customer's custom fields into another's ticket form.
+        const byTenant = new Map();
+        const conflicts = [];
+        const bucket = (tenantId) => {
+            const existing = byTenant.get(tenantId);
+            if (existing)
+                return existing;
+            const created = new Map();
+            byTenant.set(tenantId, created);
+            return created;
+        };
+        const absorb = (field, tenantId, origin) => {
+            const converted = toMetaFieldConfig(field);
+            if (!converted)
+                return;
+            const target = bucket(tenantId);
+            const existing = target.get(converted.name);
+            if (!existing) {
+                target.set(converted.name, converted);
+                return;
+            }
+            if (existing.type !== converted.type) {
+                conflicts.push(`"${converted.name}" is ${existing.type} elsewhere but ${converted.type} in ${origin}`);
+            }
+        };
+        // Definitions as configured on the form.
+        for (const formConfig of await (0, pass_js_1.all)(() => (0, pass_js_1.scopeToTenant)(new node_1.default.Query(index_js_1.Maintenance_Ticket_FormConfig), config.tenantId), config.batchSize)) {
+            const raw = formConfig.get("config");
+            const fields = Array.isArray(raw) ? raw : raw?.config;
+            const metaEntry = fields?.find((f) => f?.name === "meta");
+            const tenantId = (0, pass_js_1.refId)(formConfig.get("tenant")) ?? NO_TENANT;
+            for (const field of metaEntry?.fields ?? []) {
+                absorb(field, tenantId, `FormConfig ${formConfig.id}`);
+            }
+        }
+        // Definitions as they actually appear on tickets. The form config can have been
+        // edited since, so a ticket may carry a field the config no longer defines —
+        // and pass 09 would then write a value with no definition behind it.
+        let ticketsWithMeta = 0;
+        for (const ticket of await (0, pass_js_1.all)(() => (0, pass_js_1.scopeToTenant)(new node_1.default.Query(index_js_1.Maintenance_Ticket), config.tenantId).exists("meta"), config.batchSize)) {
+            const meta = ticket.get("meta");
+            if (!meta?.fields?.length)
+                continue;
+            ticketsWithMeta += 1;
+            const tenantId = (0, pass_js_1.refId)(ticket.get("tenant")) ?? NO_TENANT;
+            for (const field of meta.fields) {
+                absorb(field, tenantId, `Ticket ${ticket.id}`);
+            }
+        }
+        for (const conflict of conflicts) {
+            report.warn(entry, `meta field type conflict: ${conflict} — first wins`);
+        }
+        if (byTenant.size === 0) {
+            report.warn(entry, "no ticket meta fields found in any form config or ticket — nothing to configure");
+            return;
+        }
+        const contextString = (0, ptr_js_1.contextToString)(exports.TICKET_META_CONTEXT);
+        for (const [tenantId, fieldsByName] of byTenant) {
+            const fields = [...fieldsByName.values()];
+            const label = tenantId || "(no tenant)";
+            report.info(entry, `tenant ${label}: ${fields.length} meta field definition(s) collected ` +
+                `(from ${ticketsWithMeta} ticket(s) with meta across all tenants)`);
+            const existing = await findConfig(contextString, tenantId);
+            const target = existing ?? new index_js_1.Meta_Config();
+            target.set("context", contextString);
+            target.set("config", { fields });
+            if (tenantId)
+                target.set("tenant", (0, ptr_js_1.tenantPtr)(tenantId));
+            if (!existing) {
+                target.setACL((0, acl_js_1.migrationAcl)({ tenantId: tenantId || undefined }));
+            }
+            if (config.dryRun) {
+                existing ? entry.updated++ : entry.created++;
+                continue;
+            }
+            try {
+                // No historical timestamp to preserve: the shared config is a v2 artefact
+                // synthesised from many v1 records, not a migrated row.
+                await (0, acl_js_1.saveMigrated)(config, target, {
+                    className: index_js_1.Meta_Config.className,
+                    isNew: !existing,
+                });
+                existing ? entry.updated++ : entry.created++;
+            }
+            catch (error) {
+                report.error(entry, `Meta_Config for tenant ${label} failed: ${error.message}`);
+            }
+        }
+    },
+};

package/dist/scripts/migration/passes/08-tickets.d.ts

@@ -0,0 +1,27 @@
+import { type Pass } from "../lib/pass.js";
+/** Marker written to `Ticket.origin` so a v2 ticket can be traced back. */
+export declare const legacyOrigin: (oldTicketId: string) => string;
+/**
+ * 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.
+ */
+export declare function closureOf(tagId: string, parentOf: Map<string, string | undefined>): string[];
+/**
+ * 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.
+ */
+export declare const pass08: Pass;