@opencrvs/toolkit 2.0.0-rc.fc7f7fc → 2.0.0-rc.fef9d21

package/dist/migrations/v2.0/make-built-in-validate-actions-custom.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"make-built-in-validate-actions-custom.d.ts","sourceRoot":"","sources":["../../../src/migrations/v2.0/make-built-in-validate-actions-custom.ts"],"names":[],"mappings":"AA6WA,iBAAe,IAAI,kBAiDlB;AAED,OAAO,EAAE,IAAI,EAAE,CAAA"}
+{"version":3,"file":"make-built-in-validate-actions-custom.d.ts","sourceRoot":"","sources":["../../../src/migrations/v2.0/make-built-in-validate-actions-custom.ts"],"names":[],"mappings":"AA2WA,iBAAe,IAAI,kBAiDlB;AAED,OAAO,EAAE,IAAI,EAAE,CAAA"}

package/dist/migrations/v2.0/make-built-in-validate-actions-custom.js

@@ -45,7 +45,6 @@ exports.main = main;
  */
 const ts_morph_1 = require("ts-morph");
 const path_1 = __importDefault(require("path"));
-const _1 = require(".");
 const TOOLKIT_EVENTS_MODULE = '@opencrvs/toolkit/events';
 const REQUIRED_SYMBOLS = [
     'ConditionalType',
@@ -263,7 +262,7 @@ function processFile(filePath, project) {
         // Resolve the root event type for use in the auditHistoryLabel id
         const eventType = resolveEventType(configArg);
         if (!eventType) {
-            console.warn(`  [${path_1.default.relative((0, _1.getCwd)(), configArg.getSourceFile().getFilePath())}] Could not resolve root 'type' from defineConfig — skipping auditHistoryLabel id generation`);
+            console.warn(`  [${path_1.default.relative(process.cwd(), configArg.getSourceFile().getFilePath())}] Could not resolve root 'type' from defineConfig — skipping auditHistoryLabel id generation`);
         }
         // Iterate over every element in the `actions` array
         let fileNeedsImports = false;
@@ -276,7 +275,7 @@ function processFile(filePath, project) {
                 transformedCount++;
                 fileNeedsImports = true;
                 configHadValidateAction = true;
-                console.log(`  [${path_1.default.relative((0, _1.getCwd)(), filePath)}] Transformed VALIDATE action to CUSTOM with customActionType: '${VALIDATE_DECLARATION_VALUE}'`);
+                console.log(`  [${path_1.default.relative(process.cwd(), filePath)}] Transformed VALIDATE action to CUSTOM with customActionType: '${VALIDATE_DECLARATION_VALUE}'`);
             }
         }
         // Add top-level flags array to the config object if a VALIDATE action was found
@@ -296,7 +295,7 @@ function processFile(filePath, project) {
   }
 ]`
             });
-            console.log(`  [${path_1.default.relative((0, _1.getCwd)(), filePath)}] Added top-level 'flags' array to defineConfig`);
+            console.log(`  [${path_1.default.relative(process.cwd(), filePath)}] Added top-level 'flags' array to defineConfig`);
         }
         if (fileNeedsImports) {
             ensureImports(sourceFile);
@@ -306,7 +305,7 @@ function processFile(filePath, project) {
 }
 function main() {
     return __awaiter(this, void 0, void 0, function* () {
-        const srcDir = path_1.default.join((0, _1.getCwd)(), 'src');
+        const srcDir = path_1.default.join(process.cwd(), 'src');
         console.log(`Scanning for defineConfig calls in: ${srcDir}\n`);
         const project = new ts_morph_1.Project({
             tsConfigFilePath: path_1.default.resolve(srcDir, '../tsconfig.json'),
@@ -337,7 +336,7 @@ function main() {
         for (const filePath of modifiedFiles) {
             const sourceFile = project.getSourceFileOrThrow(filePath);
             yield sourceFile.save();
-            console.log(`  Saved: ${path_1.default.relative((0, _1.getCwd)(), filePath)}`);
+            console.log(`  Saved: ${path_1.default.relative(process.cwd(), filePath)}`);
         }
         console.log(`\nDone. Transformed ${totalTransformed} VALIDATE action(s) to CUSTOM with customActionType: '${VALIDATE_DECLARATION_VALUE}'.`);
     });

package/dist/migrations/v2.0/merge-infrastructure-directory.d.ts

@@ -0,0 +1,3 @@
+declare function main(): Promise<void>;
+export { main };
+//# sourceMappingURL=merge-infrastructure-directory.d.ts.map

package/dist/migrations/v2.0/merge-infrastructure-directory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-infrastructure-directory.d.ts","sourceRoot":"","sources":["../../../src/migrations/v2.0/merge-infrastructure-directory.ts"],"names":[],"mappings":"AAsHA,iBAAe,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAkInC;AAED,OAAO,EAAE,IAAI,EAAE,CAAA"}

package/dist/migrations/v2.0/merge-infrastructure-directory.js

@@ -0,0 +1,221 @@
+"use strict";
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ *
+ * OpenCRVS is also distributed under the terms of the Civil Registration
+ * & Healthcare Disclaimer located at http://opencrvs.org/license.
+ *
+ * Copyright (C) The OpenCRVS Authors located at https://github.com/opencrvs/opencrvs-core/blob/master/AUTHORS.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+/**
+ * Codemod: Merge upstream changes into the local `infrastructure/` directory
+ * from opencrvs/opencrvs-countryconfig.
+ *
+ * Usage:
+ *   ts-node -r tsconfig-paths/register src/migrations/v2.0/merge-infrastructure-directory.ts
+ *
+ * What it does:
+ *   1. Registers a temporary git remote that points at the canonical
+ *      opencrvs-countryconfig repository and fetches both:
+ *        - the upstream "theirs" branch (v2.0) → `UPSTREAM_BRANCH`
+ *        - the synthetic merge-base branch (latest 1.9 release line)
+ *          → `BASE_BRANCH`
+ *   2. For every file under `infrastructure/` on upstream "theirs", performs
+ *      a file-scoped 3-way merge:
+ *        - new file on upstream → checked out and staged
+ *        - existing file       → 3-way merged in place via `git merge-file`,
+ *                                using the BASE_BRANCH version of the file
+ *                                as the ancestor (or an empty file if the
+ *                                base doesn't have it)
+ *      Files local to the country config that don't exist on upstream are
+ *      left untouched.
+ *   3. Cleanly merged files are staged. Files with conflicts are left in the
+ *      working tree with standard <<<<<<< / ======= / >>>>>>> markers and
+ *      MUST be resolved manually by the developer.
+ *   4. Removes the temporary remote in all cases (success, failure, or
+ *      unexpected error) via a `finally` block.
+ *
+ * Why a content-based synthetic merge-base instead of `git merge-base`:
+ *   - Country config repos rarely share git history with
+ *     opencrvs-countryconfig (squashed forks, template-cloned repos, etc.),
+ *     so `git merge-base HEAD upstream/develop` typically returns nothing.
+ *   - With no merge-base, a 3-way merge degenerates to a 2-way diff against
+ *     an empty file — every line that differs becomes a conflict.
+ *   - `release-v1.9` is the latest 1.9.x release line on upstream and is a
+ *     near-perfect representation of "what `infrastructure/` looked like
+ *     before v2.0", regardless of whether the fork's git history reaches it.
+ *   - For files the country config never modified relative to that baseline,
+ *     `git merge-file` resolves cleanly to upstream's v2.0 version. Conflicts
+ *     are produced only where local edits genuinely overlap with v1.9 → v2.0
+ *     upstream edits — which is what the developer needs to review anyway.
+ *
+ * Why per-file merge instead of a real `git merge`:
+ *   - Limits the blast radius to `infrastructure/` only — no other paths
+ *     are touched.
+ *   - Doesn't put the repository into an in-progress merge state
+ *     (no MERGE_HEAD), so subsequent codemods/commands behave normally.
+ *   - Works regardless of whether the local repo shares history with
+ *     opencrvs-countryconfig.
+ *
+ * Caveats:
+ *   - Local edits to merged files may be overwritten where they overlap
+ *     with upstream changes. Run on a clean working tree.
+ *   - Requires git to be installed and network access to github.com.
+ *   - Requires the country config working directory to be a git repo.
+ *   - Binary files in `infrastructure/` are not merged textually; if both
+ *     sides changed a binary file, the result will be invalid and a warning
+ *     is printed.
+ *   - Forks that are on a much older 1.9.x and never merged later 1.9 patches
+ *     may see a few extra conflicts on files where 1.9.x → release-v1.9
+ *     patches and v1.9 → v2.0 changes textually overlap.
+ */
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+const checkout_upstream_files_1 = require("./checkout-upstream-files");
+// Distinct from the remote used by `checkout-upstream-files` so that a stale
+// remote left behind by an aborted run of one codemod doesn't trip up the
+// other.
+const TEMP_REMOTE = 'opencrvs-upgrade-v19-v20-codemod-merge-infra';
+const INFRASTRUCTURE_DIR = 'infrastructure';
+// Synthetic merge-base: the tip of upstream's latest 1.9.x release line.
+// We use this branch's content as the "common ancestor" for every file,
+// since most country forks don't share git history with upstream.
+const BASE_BRANCH = 'release-v1.9';
+/**
+ * Reads `git show <ref>:<path>` as a Uint8Array (binary-safe).
+ * Returns `null` if the path doesn't exist at that ref.
+ */
+function gitShowBytes(ref, path) {
+    try {
+        const buf = (0, child_process_1.execFileSync)('git', ['show', `${ref}:${path}`], {
+            cwd: process.cwd(),
+            stdio: ['ignore', 'pipe', 'pipe']
+        });
+        // Return a plain Uint8Array view to satisfy strict typings of `fs`
+        // (which want `ArrayBufferView`, not Node's `Buffer` subtype).
+        return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+    }
+    catch (_a) {
+        return null;
+    }
+}
+// ─── Entry point ─────────────────────────────────────────────────────────────
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.log(`Merging '${INFRASTRUCTURE_DIR}/' from ${checkout_upstream_files_1.UPSTREAM_URL}@${checkout_upstream_files_1.UPSTREAM_BRANCH} (base: ${BASE_BRANCH})...\n`);
+        (0, checkout_upstream_files_1.assertIsGitRepo)();
+        // Best-effort cleanup of a stale temp remote from a previous aborted run.
+        (0, checkout_upstream_files_1.tryGit)(['remote', 'remove', TEMP_REMOTE]);
+        try {
+            console.log(`  Adding temporary remote '${TEMP_REMOTE}' → ${checkout_upstream_files_1.UPSTREAM_URL}`);
+            (0, checkout_upstream_files_1.runGit)(['remote', 'add', TEMP_REMOTE, checkout_upstream_files_1.UPSTREAM_URL], { silent: true });
+            // Fetch both branches at depth=1 — we only need their tip contents,
+            // not their history (the merge is content-based, not history-based).
+            console.log(`  Fetching ${TEMP_REMOTE}/{${checkout_upstream_files_1.UPSTREAM_BRANCH},${BASE_BRANCH}} (depth 1)...`);
+            (0, checkout_upstream_files_1.runGit)(['fetch', '--depth=1', TEMP_REMOTE, checkout_upstream_files_1.UPSTREAM_BRANCH, BASE_BRANCH]);
+            const ref = `${TEMP_REMOTE}/${checkout_upstream_files_1.UPSTREAM_BRANCH}`;
+            const baseRef = `${TEMP_REMOTE}/${BASE_BRANCH}`;
+            // -z gives NUL-separated paths so filenames with spaces or newlines
+            // survive the round-trip.
+            const upstreamFiles = (0, checkout_upstream_files_1.runGit)([
+                'ls-tree',
+                '-r',
+                '--name-only',
+                '-z',
+                ref,
+                '--',
+                `${INFRASTRUCTURE_DIR}/`
+            ], { silent: true })
+                .split('\0')
+                .filter(Boolean);
+            if (upstreamFiles.length === 0) {
+                console.log(`  No files found under '${INFRASTRUCTURE_DIR}/' on ${ref}. Nothing to merge.`);
+                return;
+            }
+            const tmpDir = (0, fs_1.mkdtempSync)((0, path_1.join)((0, os_1.tmpdir)(), 'opencrvs-merge-infra-'));
+            const baseTmp = (0, path_1.join)(tmpDir, 'base');
+            const theirsTmp = (0, path_1.join)(tmpDir, 'theirs');
+            let added = 0;
+            let merged = 0;
+            const conflictedFiles = [];
+            for (const file of upstreamFiles) {
+                const fullPath = (0, path_1.join)(process.cwd(), file);
+                if (!(0, fs_1.existsSync)(fullPath)) {
+                    // New upstream file — `git checkout` handles binary correctly and
+                    // stages the result, matching the UX of `checkout-upstream-files`.
+                    if ((0, checkout_upstream_files_1.tryGit)(['checkout', ref, '--', file])) {
+                        console.log(`  + ${file} (new from upstream)`);
+                        added++;
+                    }
+                    else {
+                        console.warn(`  [warn] failed to add new file ${file}`);
+                    }
+                    continue;
+                }
+                const theirContents = gitShowBytes(ref, file);
+                if (theirContents === null) {
+                    // Shouldn't happen — `ls-tree` just told us the file is there.
+                    console.warn(`  [warn] could not read ${file} from ${ref} — skipping.`);
+                    continue;
+                }
+                (0, fs_1.writeFileSync)(theirsTmp, theirContents);
+                // Pull the base version from upstream's latest 1.9 release line. If
+                // the file didn't exist there yet (added in v2.0), fall back to an
+                // empty base — `git merge-file` will then treat any local content as
+                // a local addition.
+                const baseContents = gitShowBytes(baseRef, file);
+                (0, fs_1.writeFileSync)(baseTmp, baseContents !== null && baseContents !== void 0 ? baseContents : new Uint8Array(0));
+                // `git merge-file` does an in-place 3-way merge. Exit codes:
+                //   0       → clean merge
+                //   1..N    → that many conflicts; markers written into the file
+                //   <0/127  → error (e.g. binary file rejected)
+                try {
+                    (0, child_process_1.execFileSync)('git', ['merge-file', fullPath, baseTmp, theirsTmp], {
+                        cwd: process.cwd(),
+                        stdio: ['ignore', 'pipe', 'pipe']
+                    });
+                    (0, checkout_upstream_files_1.runGit)(['add', '--', file], { silent: true });
+                    merged++;
+                }
+                catch (err) {
+                    const status = err.status;
+                    if (typeof status === 'number' && status > 0) {
+                        conflictedFiles.push(file);
+                        console.warn(`  ! ${file} (${status} conflict${status > 1 ? 's' : ''})`);
+                    }
+                    else {
+                        conflictedFiles.push(file);
+                        console.warn(`  [warn] merge failed for ${file} (likely binary or unreadable) — left untouched.`);
+                    }
+                }
+            }
+            console.log(`\n  Done. ${added} added, ${merged} merged cleanly, ${conflictedFiles.length} with conflicts.`);
+            if (conflictedFiles.length > 0) {
+                console.warn(`\n  NOTE: ${conflictedFiles.length} file(s) under '${INFRASTRUCTURE_DIR}/' have merge conflicts that you must resolve manually.\n` +
+                    `        Look for the standard conflict markers (<<<<<<<, =======, >>>>>>>) in:\n` +
+                    conflictedFiles.map((f) => `          - ${f}`).join('\n') +
+                    `\n        After resolving, stage the fixes with: git add ${INFRASTRUCTURE_DIR}/`);
+            }
+        }
+        finally {
+            if ((0, checkout_upstream_files_1.tryGit)(['remote', 'remove', TEMP_REMOTE])) {
+                console.log(`  Removed temporary remote '${TEMP_REMOTE}'.`);
+            }
+        }
+    });
+}

package/dist/migrations/v2.0/migrate-application-config-url.d.ts

@@ -0,0 +1,3 @@
+declare function main(): Promise<void>;
+export { main };
+//# sourceMappingURL=migrate-application-config-url.d.ts.map

package/dist/migrations/v2.0/migrate-application-config-url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrate-application-config-url.d.ts","sourceRoot":"","sources":["../../../src/migrations/v2.0/migrate-application-config-url.ts"],"names":[],"mappings":"AAwUA,iBAAe,IAAI,kBAqElB;AAED,OAAO,EAAE,IAAI,EAAE,CAAA"}

package/dist/migrations/v2.0/migrate-application-config-url.js

@@ -0,0 +1,342 @@
+"use strict";
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ *
+ * OpenCRVS is also distributed under the terms of the Civil Registration
+ * & Healthcare Disclaimer located at http://opencrvs.org/license.
+ *
+ * Copyright (C) The OpenCRVS Authors located at https://github.com/opencrvs/opencrvs-core/blob/master/AUTHORS.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+/**
+ * Codemod: Replace usages of the legacy `APPLICATION_CONFIG_URL` env-derived
+ * constant with direct usage of the v2.0 `applicationConfig` object.
+ *
+ * Background:
+ *   In v1.9 country configs read application configuration over HTTP from
+ *   the config service via `APPLICATION_CONFIG_URL`. In v2.0 the config is
+ *   defined statically in `src/api/application/application-config.ts` (as
+ *   `applicationConfig`) and consumed by import.
+ *
+ * What it does (per source file under `src/`):
+ *   1. If the file imports `APPLICATION_CONFIG_URL` (from any module), the
+ *      named import is removed; if that leaves the import declaration empty,
+ *      the whole declaration is removed.
+ *   2. An import of `applicationConfig` from
+ *      `@countryconfig/api/application/application-config` is added
+ *      (idempotent — re-uses an existing import declaration if one exists).
+ *   3. Block-bodied functions whose body references *both*
+ *      `APPLICATION_CONFIG_URL` *and* a `fetch(...)` call are recognised
+ *      as "config-fetcher" functions. Their entire body is replaced with
+ *      `return applicationConfig` — eliminating the URL construction,
+ *      `fetch`, JSON parsing, and unwrapping of `.config`. Callers
+ *      (`await getApplicationConfig()` etc.) keep working because async
+ *      functions still wrap the return value in a `Promise`.
+ *   4. Any remaining bare identifier references to `APPLICATION_CONFIG_URL`
+ *      are renamed to `applicationConfig`. Property names (e.g.
+ *      `obj.APPLICATION_CONFIG_URL` or `{ APPLICATION_CONFIG_URL: x }`)
+ *      are left alone.
+ *
+ * Caveats:
+ *   - Wholesale body replacement of config-fetcher functions destroys any
+ *     custom logic the country had inlined there (error handling, derived
+ *     fields, etc.). Each rewrite is logged so the developer can review
+ *     the diff and re-apply customisations on top of `applicationConfig`.
+ *   - The shape of v2.0 `applicationConfig` is not identical to the v1.9
+ *     `IApplicationConfigResponse.config` — callers that destructured
+ *     v1.9-only fields will produce TypeScript errors and need manual
+ *     review.
+ *   - Files that have a local declaration named `applicationConfig` are
+ *     skipped to avoid a name collision; a warning is logged so the
+ *     developer can resolve it manually.
+ *   - Files that reference `APPLICATION_CONFIG_URL` *without* importing it
+ *     (e.g. as a local variable) are skipped — we only rewrite imported
+ *     usages.
+ *   - Concise-body arrow functions (`() => fetch(...)`) are not
+ *     body-rewritten — only their identifier is renamed in step 4. If a
+ *     country happens to inline the fetch in concise form, the result
+ *     will need manual cleanup.
+ */
+const path_1 = __importDefault(require("path"));
+const ts_morph_1 = require("ts-morph");
+const TARGET_IDENTIFIER = 'APPLICATION_CONFIG_URL';
+const REPLACEMENT_IDENTIFIER = 'applicationConfig';
+const REPLACEMENT_MODULE = '@countryconfig/api/application/application-config';
+/**
+ * Function-like syntax kinds whose `body` we know how to replace via
+ * `setBodyText` (i.e. block-bodied callables).
+ */
+const FUNCTION_LIKE_KINDS = [
+    ts_morph_1.SyntaxKind.FunctionDeclaration,
+    ts_morph_1.SyntaxKind.FunctionExpression,
+    ts_morph_1.SyntaxKind.ArrowFunction,
+    ts_morph_1.SyntaxKind.MethodDeclaration
+];
+/**
+ * Returns the name of the function-like node for logging purposes.
+ * Falls back to `<anonymous>` when nothing useful can be derived.
+ */
+function describeFunction(node) {
+    var _a, _b, _c;
+    if (ts_morph_1.Node.isFunctionDeclaration(node) || ts_morph_1.Node.isMethodDeclaration(node)) {
+        return (_a = node.getName()) !== null && _a !== void 0 ? _a : '<anonymous>';
+    }
+    // FunctionExpression / ArrowFunction: try to pick up the assignment target.
+    const parent = node.getParent();
+    if (parent && ts_morph_1.Node.isVariableDeclaration(parent)) {
+        return parent.getName();
+    }
+    if (parent && ts_morph_1.Node.isPropertyAssignment(parent)) {
+        return parent.getName();
+    }
+    if (ts_morph_1.Node.isFunctionExpression(node) &&
+        node.getNameNode() !== undefined) {
+        return (_c = (_b = node.getNameNode()) === null || _b === void 0 ? void 0 : _b.getText()) !== null && _c !== void 0 ? _c : '<anonymous>';
+    }
+    return '<anonymous>';
+}
+/**
+ * True when the node has a block body that we can safely replace via
+ * `setBodyText` (excludes concise-body arrow functions like `() => 1`).
+ */
+function hasBlockBody(node) {
+    if (ts_morph_1.Node.isFunctionDeclaration(node) ||
+        ts_morph_1.Node.isFunctionExpression(node) ||
+        ts_morph_1.Node.isMethodDeclaration(node)) {
+        return node.getBody() !== undefined;
+    }
+    if (ts_morph_1.Node.isArrowFunction(node)) {
+        return node.getBody().getKind() === ts_morph_1.SyntaxKind.Block;
+    }
+    return false;
+}
+/**
+ * True when the node's body references `APPLICATION_CONFIG_URL` AND
+ * contains at least one `fetch(...)` call — the "config-fetcher" signature.
+ */
+function isConfigFetcher(node) {
+    let referencesTarget = false;
+    let callsFetch = false;
+    for (const id of node.getDescendantsOfKind(ts_morph_1.SyntaxKind.Identifier)) {
+        const text = id.getText();
+        if (!referencesTarget && text === TARGET_IDENTIFIER)
+            referencesTarget = true;
+        if (!callsFetch && text === 'fetch') {
+            // Only count `fetch(` calls, not bare references like
+            // `const f = fetch` (rare, but pedantic).
+            const parent = id.getParent();
+            if (ts_morph_1.Node.isCallExpression(parent) &&
+                parent.getExpression() === id) {
+                callsFetch = true;
+            }
+        }
+        if (referencesTarget && callsFetch)
+            return true;
+    }
+    return false;
+}
+function processFile(sourceFile) {
+    const importsWithTarget = sourceFile
+        .getImportDeclarations()
+        .filter((decl) => decl.getNamedImports().some((ni) => ni.getName() === TARGET_IDENTIFIER));
+    if (importsWithTarget.length === 0) {
+        return { changed: false, rewrittenFunctions: [], renamedReferences: 0 };
+    }
+    // Bail out if a same-named local would collide with the new identifier.
+    // Imported `applicationConfig` doesn't count as a local declaration.
+    const collidingLocals = sourceFile
+        .getDescendantsOfKind(ts_morph_1.SyntaxKind.Identifier)
+        .filter((id) => id.getText() === REPLACEMENT_IDENTIFIER)
+        .filter((id) => {
+        const parent = id.getParent();
+        const kind = parent.getKind();
+        return (kind === ts_morph_1.SyntaxKind.VariableDeclaration ||
+            kind === ts_morph_1.SyntaxKind.FunctionDeclaration ||
+            kind === ts_morph_1.SyntaxKind.ClassDeclaration ||
+            kind === ts_morph_1.SyntaxKind.Parameter);
+    });
+    if (collidingLocals.length > 0) {
+        return {
+            changed: false,
+            rewrittenFunctions: [],
+            renamedReferences: 0,
+            skippedReason: `local declaration named '${REPLACEMENT_IDENTIFIER}' would collide`
+        };
+    }
+    // ─── 1. Rewrite "config-fetcher" function bodies ───────────────────────
+    // We only replace block-bodied functions that reference both
+    // APPLICATION_CONFIG_URL and `fetch(...)`. The bodies are replaced with
+    // `return applicationConfig`, which works for both sync and async
+    // functions (the latter automatically wraps the value in a Promise).
+    const candidateFunctions = FUNCTION_LIKE_KINDS.flatMap((kind) => sourceFile.getDescendantsOfKind(kind));
+    // Outermost-first: when functions are nested, rewriting the outer one
+    // also discards the inner one, so we shouldn't try to rewrite the inner
+    // afterwards. Sorting by start position handles this; we additionally
+    // filter out any candidate whose ancestor we already rewrote.
+    candidateFunctions.sort((a, b) => a.getStart() - b.getStart());
+    const rewrittenFunctions = [];
+    const rewrittenSet = new Set();
+    for (const fn of candidateFunctions) {
+        if (!hasBlockBody(fn))
+            continue;
+        if (!isConfigFetcher(fn))
+            continue;
+        // Skip if any ancestor was already rewritten (its descendants are now
+        // detached from the source file).
+        let inRewrittenAncestor = false;
+        let cursor = fn.getParent();
+        while (cursor) {
+            if (rewrittenSet.has(cursor)) {
+                inRewrittenAncestor = true;
+                break;
+            }
+            cursor = cursor.getParent();
+        }
+        if (inRewrittenAncestor)
+            continue;
+        const start = fn.getStart();
+        const line = sourceFile.getLineAndColumnAtPos(start).line;
+        const name = describeFunction(fn);
+        if (ts_morph_1.Node.isFunctionDeclaration(fn) ||
+            ts_morph_1.Node.isFunctionExpression(fn) ||
+            ts_morph_1.Node.isMethodDeclaration(fn) ||
+            ts_morph_1.Node.isArrowFunction(fn)) {
+            fn.setBodyText(`return ${REPLACEMENT_IDENTIFIER}`);
+        }
+        rewrittenFunctions.push({ name, line });
+        rewrittenSet.add(fn);
+    }
+    // ─── 2. Remove the `APPLICATION_CONFIG_URL` import ─────────────────────
+    for (const decl of importsWithTarget) {
+        const targetNamed = decl
+            .getNamedImports()
+            .find((ni) => ni.getName() === TARGET_IDENTIFIER);
+        targetNamed === null || targetNamed === void 0 ? void 0 : targetNamed.remove();
+        const isNowEmpty = decl.getNamedImports().length === 0 &&
+            !decl.getDefaultImport() &&
+            !decl.getNamespaceImport();
+        if (isNowEmpty)
+            decl.remove();
+    }
+    // ─── 3. Add the new `applicationConfig` import ─────────────────────────
+    const existing = sourceFile.getImportDeclaration((decl) => decl.getModuleSpecifierValue() === REPLACEMENT_MODULE);
+    if (existing) {
+        const alreadyImported = existing
+            .getNamedImports()
+            .some((ni) => ni.getName() === REPLACEMENT_IDENTIFIER);
+        if (!alreadyImported)
+            existing.addNamedImport(REPLACEMENT_IDENTIFIER);
+    }
+    else {
+        sourceFile.addImportDeclaration({
+            moduleSpecifier: REPLACEMENT_MODULE,
+            namedImports: [REPLACEMENT_IDENTIFIER]
+        });
+    }
+    // ─── 4. Rename remaining identifier references ─────────────────────────
+    // Anything still named APPLICATION_CONFIG_URL after the function-body
+    // rewrites and import cleanup is a stray reference; rename it. Iterate
+    // from highest position to lowest so `replaceWithText` doesn't shift
+    // offsets for nodes we haven't visited yet.
+    const renameTargets = sourceFile
+        .getDescendantsOfKind(ts_morph_1.SyntaxKind.Identifier)
+        .filter((id) => id.getText() === TARGET_IDENTIFIER)
+        .filter((id) => !id.getFirstAncestorByKind(ts_morph_1.SyntaxKind.ImportDeclaration))
+        .filter((id) => {
+        const parent = id.getParent();
+        const parentKind = parent.getKind();
+        if (parentKind === ts_morph_1.SyntaxKind.PropertyAccessExpression) {
+            const pae = parent.asKind(ts_morph_1.SyntaxKind.PropertyAccessExpression);
+            // Right-hand side of `x.APPLICATION_CONFIG_URL` — leave alone.
+            if (pae.getNameNode() === id)
+                return false;
+        }
+        if (parentKind === ts_morph_1.SyntaxKind.PropertyAssignment) {
+            const pa = parent.asKind(ts_morph_1.SyntaxKind.PropertyAssignment);
+            // `{ APPLICATION_CONFIG_URL: ... }` — leave the key alone.
+            if (pa.getNameNode() === id)
+                return false;
+        }
+        if (parentKind === ts_morph_1.SyntaxKind.ShorthandPropertyAssignment) {
+            // `{ APPLICATION_CONFIG_URL }` shorthand — both binding name AND
+            // referenced symbol. Leave alone here; if the user wants to rename
+            // the referenced value they should expand it manually first.
+            return false;
+        }
+        return true;
+    })
+        .sort((a, b) => b.getPos() - a.getPos());
+    for (const id of renameTargets) {
+        id.replaceWithText(REPLACEMENT_IDENTIFIER);
+    }
+    return {
+        changed: true,
+        rewrittenFunctions,
+        renamedReferences: renameTargets.length
+    };
+}
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const project = new ts_morph_1.Project({
+            tsConfigFilePath: path_1.default.resolve(process.cwd(), 'tsconfig.json'),
+            skipAddingFilesFromTsConfig: false
+        });
+        const sourceFiles = project.getSourceFiles().filter((sf) => {
+            const fp = sf.getFilePath();
+            return fp.includes('/src/') && !fp.includes('/node_modules/');
+        });
+        console.log(`Migrating '${TARGET_IDENTIFIER}' → '${REPLACEMENT_IDENTIFIER}' across ${sourceFiles.length} source file(s)...\n`);
+        let changedFiles = 0;
+        let totalRewrittenFunctions = 0;
+        let totalRenamedReferences = 0;
+        const skipped = [];
+        for (const sourceFile of sourceFiles) {
+            const filePath = sourceFile.getFilePath();
+            const rel = path_1.default.relative(process.cwd(), filePath);
+            const result = processFile(sourceFile);
+            if (result.skippedReason) {
+                skipped.push(`${rel} (${result.skippedReason})`);
+                continue;
+            }
+            if (!result.changed)
+                continue;
+            yield sourceFile.save();
+            changedFiles++;
+            totalRewrittenFunctions += result.rewrittenFunctions.length;
+            totalRenamedReferences += result.renamedReferences;
+            for (const fn of result.rewrittenFunctions) {
+                console.log(`  [${rel}:${fn.line}] Rewrote '${fn.name}' body → 'return ${REPLACEMENT_IDENTIFIER}' (config fetch eliminated)`);
+            }
+            if (result.renamedReferences > 0) {
+                console.log(`  [${rel}] Renamed ${result.renamedReferences} stray reference(s) ${TARGET_IDENTIFIER} → ${REPLACEMENT_IDENTIFIER}`);
+            }
+        }
+        if (skipped.length > 0) {
+            console.warn(`\n  ${skipped.length} file(s) skipped:\n` +
+                skipped.map((s) => `    - ${s}`).join('\n'));
+        }
+        if (changedFiles === 0) {
+            console.log(`\nNo files reference '${TARGET_IDENTIFIER}'. Nothing to do.`);
+            return;
+        }
+        console.log(`\nDone. Updated ${changedFiles} file(s): ${totalRewrittenFunctions} fetch function(s) rewritten, ${totalRenamedReferences} bare reference(s) renamed.`);
+        if (totalRewrittenFunctions > 0) {
+            console.log(`NOTE: rewriting fetch functions discards any custom logic that lived inside them. Review the diff and re-apply any country-specific adjustments on top of '${REPLACEMENT_IDENTIFIER}'.`);
+        }
+    });
+}

package/dist/migrations/v2.0/migrate-scopes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"migrate-scopes.d.ts","sourceRoot":"","sources":["../../../src/migrations/v2.0/migrate-scopes.ts"],"names":[],"mappings":"AA2VA,iBAAe,IAAI,kBAmDlB;AAED,OAAO,EAAE,IAAI,EAAE,CAAA"}
+{"version":3,"file":"migrate-scopes.d.ts","sourceRoot":"","sources":["../../../src/migrations/v2.0/migrate-scopes.ts"],"names":[],"mappings":"AAyVA,iBAAe,IAAI,kBAmDlB;AAED,OAAO,EAAE,IAAI,EAAE,CAAA"}