@openinc/parse-server-opendash 4.1.1 → 4.1.2

package/dist/i18n/de-DE/chat.json

@@ -0,0 +1,18 @@
+{
+    "message": {
+        "mention": {
+            "user": {
+                "notification": {
+                    "title": "Sie wurden in einer Nachricht erwähnt",
+                    "description": "{{username}} hat Sie in einer Nachricht erwähnt: {{- messageText}}"
+                }
+            },
+            "role": {
+                "notification": {
+                    "title": "Ihre Rolle wurde in einer Nachricht erwähnt",
+                    "description": "{{username}} hat die Rolle {{role}} in einer Nachricht erwähnt: {{- messageText}}"
+                }
+            }
+        }
+    }
+}

package/dist/i18n/de-DE/openservice.json

@@ -0,0 +1,14 @@
+{
+    "ticket": {
+        "assignment": {
+            "assigned": {
+                "title": "Ihnen wurde ein Ticket zugewiesen",
+                "description": "{{username}} hat Ihnen das Ticket {{ticketName}} zugewiesen.\n\nLink: {{- ticketLink}}"
+            },
+            "watcher": {
+                "title": "Ein Ticket wurde zugewiesen",
+                "description": "{{username}} hat das Ticket {{ticketName}} zugewiesen.\n\nLink: {{- ticketLink}}"
+            }
+        }
+    }
+}

package/dist/i18n/en-US/chat.json

@@ -0,0 +1,18 @@
+{
+    "message": {
+        "mention": {
+            "user": {
+                "notification": {
+                    "title": "You were mentioned in a message",
+                    "description": "{{username}} mentioned you in a message: {{- messageText}}"
+                }
+            },
+            "role": {
+                "notification": {
+                    "title": "Your role was mentioned in a message",
+                    "description": "{{username}} mentioned the role {{role}} in a message: {{- messageText}}"
+                }
+            }
+        }
+    }
+}

package/dist/i18n/en-US/openservice.json

@@ -0,0 +1,14 @@
+{
+    "ticket": {
+        "assignment": {
+            "assigned": {
+                "title": "You were assigned to a ticket",
+                "description": "{{username}} assigned you to ticket {{ticketName}}.\n\nLink: {{- ticketLink}}"
+            },
+            "watcher": {
+                "title": "A ticket was assigned",
+                "description": "{{username}} assigned ticket {{ticketName}}.\n\nLink: {{- ticketLink}}"
+            }
+        }
+    }
+}

package/dist/scripts/backfill-meta-contexts.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/backfill-meta-contexts.js

@@ -0,0 +1,100 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_1 = __importDefault(require("parse/node"));
+const index_js_1 = require("../features/meta/index.js");
+const index_js_2 = require("../types/index.js");
+/**
+ * One-off backfill for the `OD3_Meta_Context` directory.
+ *
+ * From here on the `Meta_Config` / `Meta_Entry` afterSave hooks keep the
+ * directory current, but they only see writes — everything already in the
+ * database predates them. This walks both classes once and registers what it
+ * finds, so the directory starts complete rather than filling in as rows happen
+ * to be touched.
+ *
+ *   PARSE_URL=… PARSE_APP_ID=… PARSE_MASTER_KEY=… \
+ *     node dist/scripts/backfill-meta-contexts.js [--dry-run]
+ *
+ * Safe to re-run: `registerMetaContext` upserts and only writes on a change.
+ */
+const BATCH_SIZE = 500;
+function requireEnv(name) {
+    const value = process.env[name];
+    if (!value) {
+        console.error(`Missing required environment variable ${name}.`);
+        process.exit(1);
+    }
+    return value;
+}
+/** Iterate a class in `createdAt` order, page by page — no skip, no cursor drift. */
+async function* pages(ctor) {
+    let after;
+    for (;;) {
+        const query = new node_1.default.Query(ctor)
+            .ascending("createdAt")
+            .limit(BATCH_SIZE);
+        // `createdAt` is not part of the generic attribute map, hence the cast.
+        if (after)
+            query.greaterThan("createdAt", after);
+        const results = await query.find({ useMasterKey: true });
+        if (results.length === 0)
+            return;
+        yield results;
+        after = results[results.length - 1].createdAt;
+        if (results.length < BATCH_SIZE)
+            return;
+    }
+}
+async function main() {
+    const dryRun = process.argv.includes("--dry-run");
+    node_1.default.initialize(requireEnv("PARSE_APP_ID"), undefined, requireEnv("PARSE_MASTER_KEY"));
+    node_1.default.serverURL =
+        process.env.PARSE_URL ?? "http://localhost:1337/parse";
+    const seen = new Set();
+    let configs = 0;
+    let entries = 0;
+    // Configs first: they carry label/description, so a context that has one is
+    // named from the start rather than being created bare by an entry.
+    for await (const page of pages(index_js_2.Meta_Config)) {
+        for (const config of page) {
+            const context = config.context;
+            if (!context)
+                continue;
+            configs++;
+            seen.add(context);
+            if (dryRun)
+                continue;
+            await (0, index_js_1.registerMetaContext)({
+                context,
+                tenant: config.tenant,
+                config,
+            });
+        }
+    }
+    for await (const page of pages(index_js_2.Meta_Entry)) {
+        for (const entry of page) {
+            const context = entry.context;
+            if (!context)
+                continue;
+            entries++;
+            seen.add(context);
+            if (dryRun)
+                continue;
+            await (0, index_js_1.registerMetaContext)({
+                context,
+                tenant: entry.tenant,
+                entryClassName: entry.entryClassName,
+            });
+        }
+    }
+    console.log(`${dryRun ? "[dry run] " : ""}scanned ${configs} configs and ${entries} entries → ${seen.size} distinct contexts`);
+    for (const context of [...seen].sort())
+        console.log(`  ${context}`);
+}
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

package/dist/scripts/migration/lib/acl.d.ts

@@ -0,0 +1,52 @@
+import type { MigrationConfig } from "./env.js";
+/**
+ * Replicates `defaultAclHandler` for migration writes.
+ *
+ * The migration runs with `OD_MIGRATION_MODE=1`, which makes that handler return
+ * early (it would otherwise fight the historical owner/tenant the migration is
+ * reconstructing). So the ACLs it would have applied have to be applied here
+ * instead — deliberately mirroring
+ * `src/features/schema/helper/defaultHandler.ts` rather than inventing a policy.
+ *
+ * Keep these two in sync: if the default handler's grants change, this changes.
+ */
+export declare function migrationAcl(options: {
+    /** The object's tenant, if it has one. */
+    tenantId?: string;
+    /** The object's owning user, if it has one (v1 `user` / v2 `createdBy`). */
+    userId?: string;
+    /** Mirrors `defaultAclHandler`'s `allowTenantUserWrite` option. */
+    allowTenantUserWrite?: boolean;
+}): Parse.ACL;
+/**
+ * Save options for SDK-path writes (updates).
+ *
+ * `skipChangelog` matters as much as the key: `hooks/_ChangeLog.ts` registers an
+ * afterSave on *every* class, so without this each migrated object would generate
+ * a `masterkey`-flagged, author-less, `createdAt = now` changelog entry — six
+ * figures of noise burying the reconstructed history it sits beside. The hook
+ * already honours this context flag, so no new switch is needed.
+ */
+export declare const MIGRATION_SAVE: {
+    readonly context: {
+        readonly skipChangelog: true;
+    };
+};
+/**
+ * The single write path every pass must use.
+ *
+ * Routes by operation, because the two need different transports:
+ *
+ * - **Create** goes over REST (`lib/rest.ts`), because the SDK silently discards
+ *   `createdAt` / `updatedAt` and would leave every migrated row stamped `now`.
+ * - **Update** goes over the SDK, which is fine — Parse ignores `createdAt` on
+ *   update anyway, and the object already has its id.
+ *
+ * Returns the object's id so callers can record the mapping.
+ */
+export declare function saveMigrated(config: MigrationConfig, object: Parse.Object, options: {
+    className: string;
+    isNew: boolean;
+    createdAt?: Date;
+    updatedAt?: Date;
+}): Promise<string>;

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

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MIGRATION_SAVE = void 0;
+exports.migrationAcl = migrationAcl;
+exports.saveMigrated = saveMigrated;
+const node_1 = __importDefault(require("parse/node"));
+const rest_js_1 = require("./rest.js");
+/**
+ * Replicates `defaultAclHandler` for migration writes.
+ *
+ * The migration runs with `OD_MIGRATION_MODE=1`, which makes that handler return
+ * early (it would otherwise fight the historical owner/tenant the migration is
+ * reconstructing). So the ACLs it would have applied have to be applied here
+ * instead — deliberately mirroring
+ * `src/features/schema/helper/defaultHandler.ts` rather than inventing a policy.
+ *
+ * Keep these two in sync: if the default handler's grants change, this changes.
+ */
+function migrationAcl(options) {
+    const acl = new node_1.default.ACL();
+    acl.setRoleReadAccess("od-admin", true);
+    acl.setRoleWriteAccess("od-admin", true);
+    if (options.userId) {
+        acl.setReadAccess(options.userId, true);
+        acl.setWriteAccess(options.userId, true);
+    }
+    if (options.tenantId) {
+        acl.setRoleReadAccess(`od-tenant-user-${options.tenantId}`, true);
+        if (options.allowTenantUserWrite) {
+            acl.setRoleWriteAccess(`od-tenant-user-${options.tenantId}`, true);
+        }
+        acl.setRoleReadAccess(`od-tenant-admin-${options.tenantId}`, true);
+        acl.setRoleWriteAccess(`od-tenant-admin-${options.tenantId}`, true);
+    }
+    return acl;
+}
+/**
+ * Save options for SDK-path writes (updates).
+ *
+ * `skipChangelog` matters as much as the key: `hooks/_ChangeLog.ts` registers an
+ * afterSave on *every* class, so without this each migrated object would generate
+ * a `masterkey`-flagged, author-less, `createdAt = now` changelog entry — six
+ * figures of noise burying the reconstructed history it sits beside. The hook
+ * already honours this context flag, so no new switch is needed.
+ */
+exports.MIGRATION_SAVE = {
+    // No `useMaintenanceKey` here: the key travels as a default header (see
+    // initParse). Passing the option would append `_MaintenanceKey` to the payload,
+    // which Parse rejects on reads and ignores on writes.
+    context: { skipChangelog: true },
+};
+/**
+ * The single write path every pass must use.
+ *
+ * Routes by operation, because the two need different transports:
+ *
+ * - **Create** goes over REST (`lib/rest.ts`), because the SDK silently discards
+ *   `createdAt` / `updatedAt` and would leave every migrated row stamped `now`.
+ * - **Update** goes over the SDK, which is fine — Parse ignores `createdAt` on
+ *   update anyway, and the object already has its id.
+ *
+ * Returns the object's id so callers can record the mapping.
+ */
+async function saveMigrated(config, object, options) {
+    if (!options.isNew) {
+        await object.save(null, exports.MIGRATION_SAVE);
+        if (!object.id)
+            throw new Error("update returned no objectId");
+        return object.id;
+    }
+    const created = await (0, rest_js_1.restCreate)(config, options.className, object, options.createdAt, options.updatedAt);
+    // Keep the in-memory object consistent with what the server stored, so callers
+    // can read `object.id` as usual.
+    object.id = created.objectId;
+    return created.objectId;
+}

package/dist/scripts/migration/lib/articleMeta.d.ts

@@ -0,0 +1,47 @@
+import { Meta_Entry } from "../../../types/index.js";
+import type { MetaFieldConfig } from "../../../types/custom/MetaField.js";
+import type { MigrationConfig } from "./env.js";
+/**
+ * Stock-keeping data for an article, kept as plugin-meta rather than columns.
+ *
+ * v1's `Maintenance_Item` tracked price, stock levels, storage location and
+ * supplier. The v2 catalogue is `OD3_BDE_Article`, which is **shared with BDE
+ * and its ABAS sync** and deliberately lean — widening it is not ours to do, and
+ * the sync overwrites the columns it owns on every run.
+ *
+ * So the data lands in a `Meta_Entry` instead, under the same
+ * `["service", <entity>, "meta"]` context every other core master-data entity
+ * uses (`constants.metaContext`). That makes it editable through the article
+ * admin view in `openservice-core` with no extra machinery.
+ *
+ * **Deliberately not `["bde","article","custom"]`.** That context belongs to the
+ * ABAS sync (`node-stack-scheduler`, `syncArticle.ts`), which replaces `config`
+ * and `values` wholesale on every run and fetches its entries with
+ * `.limit(<number of ABAS articles>)`. Sharing it would let migrated entries
+ * crowd real ABAS entries out of that limit — and any article present in both
+ * would have its values clobbered on the next sync.
+ */
+export declare const ARTICLE_META_CONTEXT: string[];
+/** The field definitions written to the shared `Meta_Config`. */
+export declare const ARTICLE_META_FIELDS: MetaFieldConfig[];
+/**
+ * v1 stores `price` as a String, and these are German-language instances.
+ *
+ * Returns `undefined` for anything unparseable so the caller can report it —
+ * silently nulling a price is exactly the kind of loss that surfaces months
+ * later as "the migration ate our prices".
+ */
+export declare function parsePrice(raw: unknown): number | undefined;
+/**
+ * Ensure the shared `Meta_Config` exists for a tenant, returning its id.
+ *
+ * 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 the migration reads with the maintenance key, which bypasses ACL entirely.
+ * An unscoped `.first()` would find some other tenant's config and overwrite it.
+ */
+export declare function ensureArticleMetaConfig(config: MigrationConfig, tenantId: string): Promise<string | undefined>;
+/** Existing article meta entries, keyed by the article they belong to. */
+export declare function loadArticleMetaEntries(config: MigrationConfig): Promise<Map<string, Meta_Entry>>;
+/** The Meta_Config ids already present, keyed by tenant. */
+export declare function loadArticleMetaConfigs(config: MigrationConfig): Promise<Map<string, string>>;

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

@@ -0,0 +1,132 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ARTICLE_META_FIELDS = exports.ARTICLE_META_CONTEXT = void 0;
+exports.parsePrice = parsePrice;
+exports.ensureArticleMetaConfig = ensureArticleMetaConfig;
+exports.loadArticleMetaEntries = loadArticleMetaEntries;
+exports.loadArticleMetaConfigs = loadArticleMetaConfigs;
+const node_1 = __importDefault(require("parse/node"));
+const index_js_1 = require("../../../types/index.js");
+const acl_js_1 = require("./acl.js");
+const ptr_js_1 = require("./ptr.js");
+const pass_js_1 = require("./pass.js");
+/**
+ * Stock-keeping data for an article, kept as plugin-meta rather than columns.
+ *
+ * v1's `Maintenance_Item` tracked price, stock levels, storage location and
+ * supplier. The v2 catalogue is `OD3_BDE_Article`, which is **shared with BDE
+ * and its ABAS sync** and deliberately lean — widening it is not ours to do, and
+ * the sync overwrites the columns it owns on every run.
+ *
+ * So the data lands in a `Meta_Entry` instead, under the same
+ * `["service", <entity>, "meta"]` context every other core master-data entity
+ * uses (`constants.metaContext`). That makes it editable through the article
+ * admin view in `openservice-core` with no extra machinery.
+ *
+ * **Deliberately not `["bde","article","custom"]`.** That context belongs to the
+ * ABAS sync (`node-stack-scheduler`, `syncArticle.ts`), which replaces `config`
+ * and `values` wholesale on every run and fetches its entries with
+ * `.limit(<number of ABAS articles>)`. Sharing it would let migrated entries
+ * crowd real ABAS entries out of that limit — and any article present in both
+ * would have its values clobbered on the next sync.
+ */
+exports.ARTICLE_META_CONTEXT = ["service", "article", "meta"];
+/** The field definitions written to the shared `Meta_Config`. */
+exports.ARTICLE_META_FIELDS = [
+    { type: "number", name: "price", label: "Preis" },
+    { type: "number", name: "stock", label: "Bestand" },
+    { type: "number", name: "stockAlarmAt", label: "Meldebestand" },
+    { type: "string", name: "stockUnit", label: "Lagereinheit" },
+    { type: "string", name: "storageLocation", label: "Lagerort" },
+    { type: "string", name: "supplier", label: "Lieferant" },
+    { type: "string", name: "category", label: "Kategorie" },
+    { type: "string", name: "orderNumber", label: "Bestellnummer" },
+    {
+        type: "select_parse",
+        name: "equipment",
+        label: "Equipment",
+        className: "OD3_Service_Equipment",
+        display: "label",
+        multiple: true,
+    },
+];
+/**
+ * v1 stores `price` as a String, and these are German-language instances.
+ *
+ * Returns `undefined` for anything unparseable so the caller can report it —
+ * silently nulling a price is exactly the kind of loss that surfaces months
+ * later as "the migration ate our prices".
+ */
+function parsePrice(raw) {
+    if (raw === undefined || raw === null)
+        return undefined;
+    const cleaned = String(raw)
+        .replace(/[^\d,.-]/g, "")
+        .replace(/\.(?=\d{3}\b)/g, "") // thousands separator
+        .replace(",", ".");
+    if (cleaned === "" || cleaned === "-")
+        return undefined;
+    const value = Number(cleaned);
+    return Number.isFinite(value) ? value : undefined;
+}
+/**
+ * Ensure the shared `Meta_Config` exists for a tenant, returning its id.
+ *
+ * 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 the migration reads with the maintenance key, which bypasses ACL entirely.
+ * An unscoped `.first()` would find some other tenant's config and overwrite it.
+ */
+async function ensureArticleMetaConfig(config, tenantId) {
+    const contextString = (0, ptr_js_1.contextToString)(exports.ARTICLE_META_CONTEXT);
+    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");
+    const existing = await query.first({});
+    const target = existing ?? new index_js_1.Meta_Config();
+    target.set("context", contextString);
+    target.set("config", { fields: exports.ARTICLE_META_FIELDS });
+    if (tenantId)
+        target.set("tenant", (0, ptr_js_1.tenantPtr)(tenantId));
+    if (!existing)
+        target.setACL((0, acl_js_1.migrationAcl)({ tenantId }));
+    if (config.dryRun)
+        return existing?.id;
+    // No historical timestamp to preserve: the shared config is a v2 artefact
+    // synthesised by the migration, not a migrated row.
+    await (0, acl_js_1.saveMigrated)(config, target, {
+        className: index_js_1.Meta_Config.className,
+        isNew: !existing,
+    });
+    return target.id;
+}
+/** Existing article meta entries, keyed by the article they belong to. */
+async function loadArticleMetaEntries(config) {
+    const byArticle = new Map();
+    const contextString = (0, ptr_js_1.contextToString)(exports.ARTICLE_META_CONTEXT);
+    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.BDE_Article.className), config.batchSize)) {
+        for (const row of page) {
+            const objectId = row.get("entryObjectId");
+            if (objectId)
+                byArticle.set(objectId, row);
+        }
+    }
+    return byArticle;
+}
+/** The Meta_Config ids already present, keyed by tenant. */
+async function loadArticleMetaConfigs(config) {
+    const byTenant = new Map();
+    const contextString = (0, ptr_js_1.contextToString)(exports.ARTICLE_META_CONTEXT);
+    for (const row of await (0, pass_js_1.all)(() => new node_1.default.Query(index_js_1.Meta_Config).equalTo("context", contextString), config.batchSize)) {
+        if (row.id)
+            byTenant.set((0, pass_js_1.refId)(row.get("tenant")) ?? "", row.id);
+    }
+    return byTenant;
+}

package/dist/scripts/migration/lib/env.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Runtime configuration for the openservice v1 → v2 migration.
+ *
+ * See `plugins/openservice/MIGRATION_PLAN.md` in the opendash repo for the full
+ * plan; §3 covers why this runs on the maintenance key.
+ */
+export interface MigrationConfig {
+    parseUrl: string;
+    appId: string;
+    maintenanceKey: string;
+    /** Restrict the run to one tenant's data. Omit to process every tenant. */
+    tenantId?: string;
+    /** Run only these passes (by id, e.g. `["01", "08"]`). Omit to run all. */
+    only?: string[];
+    /** Read and report, write nothing. */
+    dryRun: boolean;
+    /** Reuse a previous run id so its MigrationMap rows are recognised. */
+    runId: string;
+    /** Rows fetched per query page. */
+    batchSize: number;
+}
+export declare class MigrationConfigError extends Error {
+}
+/**
+ * Build the config from argv + env, failing loudly on anything missing.
+ *
+ * The maintenance key is deliberately required rather than falling back to the
+ * master key: a master-key write silently stamps `createdAt = now`
+ * (`parse-server/lib/RestWrite.js` — the custom-timestamp branch is guarded by
+ * `auth.isMaintenance`), which would destroy ticket age and the reconstructed
+ * history without raising a single error. Failing to start is far better than
+ * completing with wrong timestamps.
+ */
+export declare function readConfig(argv: string[]): MigrationConfig;
+/**
+ * Point the Parse SDK at the target server, authenticating as maintenance.
+ *
+ * The key goes in a **default request header**, not through the SDK's
+ * `useMaintenanceKey` option. That option puts `_MaintenanceKey` into the request
+ * payload — which for a GET becomes a query parameter, and Parse Server rejects it
+ * outright: `Invalid parameter for query: _MaintenanceKey`
+ * (`Routers/ClassesRouter.js`). So every read would fail. The header form is what
+ * `middlewares.js` actually reads (`X-Parse-Maintenance-Key`), and it applies
+ * uniformly to reads and writes.
+ */
+export declare function initParse(config: MigrationConfig): void;
+/**
+ * Read options for every query in the migration.
+ *
+ * Deliberately empty: authentication rides on the default header set in
+ * {@link initParse}, because the SDK's `useMaintenanceKey` option would be sent as
+ * a query parameter and rejected. Kept as a named constant so call sites still
+ * document that they are reading with elevated rights — RestQuery treats
+ * `isMaintenance` alongside `isMaster`, so these reads bypass ACL and CLP.
+ */
+export declare const MK: {};

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

@@ -0,0 +1,106 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MK = exports.MigrationConfigError = void 0;
+exports.readConfig = readConfig;
+exports.initParse = initParse;
+const node_1 = __importDefault(require("parse/node"));
+class MigrationConfigError extends Error {
+}
+exports.MigrationConfigError = MigrationConfigError;
+function requireEnv(name, hint) {
+    const value = process.env[name];
+    if (!value) {
+        throw new MigrationConfigError(`Missing required environment variable ${name}.\n  ${hint}`);
+    }
+    return value;
+}
+/**
+ * Build the config from argv + env, failing loudly on anything missing.
+ *
+ * The maintenance key is deliberately required rather than falling back to the
+ * master key: a master-key write silently stamps `createdAt = now`
+ * (`parse-server/lib/RestWrite.js` — the custom-timestamp branch is guarded by
+ * `auth.isMaintenance`), which would destroy ticket age and the reconstructed
+ * history without raising a single error. Failing to start is far better than
+ * completing with wrong timestamps.
+ */
+function readConfig(argv) {
+    const flag = (name) => {
+        const hit = argv.find((a) => a.startsWith(`--${name}=`));
+        return hit ? hit.slice(name.length + 3) : undefined;
+    };
+    const has = (name) => argv.includes(`--${name}`);
+    if (process.env.OD_MIGRATION_MODE !== "1") {
+        throw new MigrationConfigError("OD_MIGRATION_MODE must be set to 1 on BOTH this process and the Parse " +
+            "Server it talks to.\n" +
+            "  Server-side it gates defaultHandler/defaultAclHandler (without it every " +
+            "maintenance-key write fails on the missing user) and suppresses assignment " +
+            "notifications.\n" +
+            "  See src/features/schema/helper/migrationMode.ts");
+    }
+    const only = flag("only");
+    return {
+        parseUrl: process.env.PARSE_URL ?? "http://localhost:1337/parse",
+        appId: requireEnv("PARSE_APP_ID", "The Parse application id, e.g. openinc-node-docker-dev."),
+        maintenanceKey: requireEnv("PARSE_MAINTENANCE_KEY", "Parse Server's `maintenanceKey` — the only auth level allowed to write a " +
+            "historical createdAt. Set PARSE_SERVER_MAINTENANCE_KEY on the server, and " +
+            "note maintenanceKeyIps defaults to localhost, so run this ON the Parse host."),
+        tenantId: flag("tenant"),
+        only: only ? only.split(",").map((s) => s.trim()) : undefined,
+        dryRun: has("dry-run"),
+        runId: flag("resume") ?? `run-${new Date().toISOString()}`,
+        batchSize: readBatchSize(flag("batch")),
+    };
+}
+/**
+ * Page size, validated rather than trusted.
+ *
+ * `Number("abc")` is `NaN`, and `.limit(NaN)` produces a query that fails in a way
+ * that points nowhere near the flag that caused it. The upper bound is a guard
+ * against Parse's `maxLimit` clamping: asking for more than the server allows makes
+ * every page come back short, which is safe for the paging loop (it stops only on
+ * an empty page) but wastes the request — so refuse the obviously-wrong value
+ * instead of quietly doing something else.
+ */
+function readBatchSize(raw) {
+    if (raw === undefined)
+        return 500;
+    const value = Number(raw);
+    if (!Number.isInteger(value) || value < 1 || value > 1000) {
+        throw new MigrationConfigError(`--batch must be an integer between 1 and 1000 (got "${raw}").\n` +
+            `  1000 is Parse's practical page ceiling; the default of 500 is fine at ` +
+            `this data volume.`);
+    }
+    return value;
+}
+/**
+ * Point the Parse SDK at the target server, authenticating as maintenance.
+ *
+ * The key goes in a **default request header**, not through the SDK's
+ * `useMaintenanceKey` option. That option puts `_MaintenanceKey` into the request
+ * payload — which for a GET becomes a query parameter, and Parse Server rejects it
+ * outright: `Invalid parameter for query: _MaintenanceKey`
+ * (`Routers/ClassesRouter.js`). So every read would fail. The header form is what
+ * `middlewares.js` actually reads (`X-Parse-Maintenance-Key`), and it applies
+ * uniformly to reads and writes.
+ */
+function initParse(config) {
+    node_1.default.initialize(config.appId);
+    node_1.default.serverURL = config.parseUrl;
+    node_1.default.CoreManager.set("REQUEST_HEADERS", {
+        "X-Parse-Maintenance-Key": config.maintenanceKey,
+    });
+}
+/**
+ * Read options for every query in the migration.
+ *
+ * Deliberately empty: authentication rides on the default header set in
+ * {@link initParse}, because the SDK's `useMaintenanceKey` option would be sent as
+ * a query parameter and rejected. Kept as a named constant so call sites still
+ * document that they are reading with elevated rights — RestQuery treats
+ * `isMaintenance` alongside `isMaster`, so these reads bypass ACL and CLP.
+ */
+exports.MK = {};